Connect Airtable to Self-Hosted AI on GPU

What You’ll Connect

After this guide, your Airtable bases will have AI-powered fields populated by your own GPU server — no API costs, no rate limits. New records trigger calls to your self-hosted LLM on dedicated GPU hardware, and the AI output is written directly back into Airtable columns — automating classification, summarisation, and enrichment tasks at scale.

The integration uses Airtable’s Scripting extension or Automations feature to send record data to your vLLM or Ollama endpoint. This is ideal for teams running CRM pipelines, content calendars, or inventory databases that benefit from AI processing without external vendor dependencies.

Automation Trigger –> Script/Webhook –> GPU Server (vLLM) | (new/updated record) fetch() call | Record with POST payload LLM inference input fields to API on dedicated GPU | | Updated record <-- Script updates <-- JSON response <-- Completion with AI fields record via API from GPU server returned -->

Prerequisites

• A GigaGPU server running an LLM with an OpenAI-compatible API (setup guide)
• An Airtable base with a table containing input data and empty fields for AI output
• Airtable Pro or higher (required for Automations with scripting actions)
• HTTPS endpoint for your GPU server with valid TLS (Nginx proxy guide)
• API key for your inference endpoint (security guide)

Integration Steps

Open your Airtable base and create two fields in your target table: an input field (e.g., “Description” as long text) and an output field (e.g., “AI Category” as single-line text). Navigate to Automations and create a new automation triggered by “When a record matches conditions” — for example, when the “AI Category” field is empty.

Add a Run a script action. The script reads the triggering record’s input field, sends it to your GPU inference API via a fetch request, and updates the record with the model’s response. Airtable’s scripting environment supports fetch() for external HTTP calls.

Map the input record ID into the script action so it knows which record to read and update. The automation runs every time a new record meets the trigger condition, creating a hands-off AI processing pipeline.

Code Example

This Airtable Automation script calls your GPU-hosted model and writes the result back to the record using the OpenAI-compatible format:

// Airtable Automation Script Action
const inputConfig = input.config();
const recordId = inputConfig.recordId;
const description = inputConfig.description;

const GPU_URL = "https://your-gpu-server.gigagpu.com/v1/chat/completions";
const API_KEY = "sk-your-gpu-api-key";

const response = await fetch(GPU_URL, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "meta-llama/Llama-3-70b-chat-hf",
    messages: [
      { role: "system", content: "Classify the following item into one category: Electronics, Clothing, Food, Home, Other. Reply with only the category name." },
      { role: "user", content: description }
    ],
    max_tokens: 20,
    temperature: 0.0
  })
});

const data = await response.json();
const category = data.choices[0].message.content.trim();

const table = base.getTable("Products");
await table.updateRecordAsync(recordId, { "AI Category": category });

Testing Your Integration

Add a test record to your table with a description but no AI Category. The automation should trigger within seconds, call your GPU server, and populate the category field. Check the automation’s run history in Airtable to verify each step completed successfully.

Test with different record types to confirm the model classifies correctly. Monitor your GPU server logs to ensure requests arrive and complete within Airtable’s script timeout (30 seconds for automations). If inference takes longer, consider using a smaller model or reducing max tokens.

Production Tips

Airtable automations run sequentially within a base — if 50 records need processing at once, they queue. For bulk operations, write an external script that queries the Airtable API for unprocessed records, batches the inference requests to your GPU, and updates records in parallel.

Store your GPU API key in Airtable’s input configuration rather than hardcoding it in the script. This makes key rotation easier and keeps credentials out of shared automation views. For additional security, route requests through a middleware layer that adds authentication headers.

For teams using Airtable as a lightweight CRM or project tracker, AI-powered field enrichment saves hours of manual tagging. Pair your open-source LLM with Airtable’s formula fields to build computed views that combine AI output with existing data. Explore more integration tutorials or start with GigaGPU dedicated GPU hosting to automate your Airtable workflows.