Airtable Text Classification: Label Records Automatically with a Run-a-Script Automation and Jev

Airtable bases often collect free text that someone sorts by hand: form submissions, customer requests, feedback, applications to a program, content ideas. Classification means reading the text in one long-text field and filling one category from a short, fixed list, so views, filters, and the next automation can work without a person reading every row first. A practical table needs four fields: the source text (Long text), Category (Single select whose options match your label IDs exactly, for example billing, bug, feature_request, other), Confidence (Number with two decimals), and Needs review (Checkbox). Keep the category list short and mutually exclusive, and always include other, so the model has an honest place for text that fits nothing. If urgency also matters, ask it as a separate yes/no question rather than adding urgent to the category list; mixing the two makes both worse. This guide covers one category per record. If a record can belong to several categories at once, use a Multiple select field and read the multi-label guide first.

Five steps. 1) Create the four fields above and add every label ID as a Single select option before the first run; the script writes the option by name, so the names must match. 2) In Automations, create an automation with the trigger “When a record matches conditions” and two conditions: the text field is not empty and Category is empty. This fires when a record enters that state, for example when a form submission arrives, and writing Category moves the record out of the condition, so the automation does not loop on its own update. 3) Add the action “Run a script”. In the input variables sidebar, add recordId mapped to the Airtable record ID from the trigger and text mapped to the text field. 4) Create a JevModel API key in Console → API keys from an account with a verified email, and add it in the script editor’s Secrets tab as JEVMODEL_API_KEY; the script reads it with input.secret("JEVMODEL_API_KEY"). Airtable restricts editing of scripts that use secrets to people who can access those secrets and redacts secrets from console output. 5) Test the action on a sample record, check the run history and execution log, then turn the automation on. A failed Jev call should leave Category empty and tick Needs review, so a temporary error never mislabels a record.

On the Airtable side, the help center lists limits for the Run a script action: a script timeout documented as 30 seconds (temporarily raised to 120 seconds at the time of writing), a 30-second timeout per fetch, a 12-second timeout for scripting API calls, 512 MB of memory, 50 fetch requests and 30 selectRecords queries per run, and up to 15 mutations per second, each changing up to 50 records. The action is available on all plan types with varying limitations, but not during a Team plan trial. One record per run, as in the example, stays far inside these limits. On the JevModel side, the whole request (state plus questions) must stay within 8,000 characters, so cut long text before sending it; the example keeps the first 6,000 characters. A request can ask 1 to 8 questions; a Choice has 2 to 12 options whose IDs start with a lowercase letter and use only lowercase letters, digits, and underscores, and a Score has 2 to 10 ordered levels. There is no model field and no idempotency key: if you re-run the automation on a record, it is a new request and billed again. Failed runs are refunded. Every labeled record is one ordinary API request charged in tokens from your balance; verified accounts start with 100,000 free tokens, and paid packs are listed on the pricing page.

All three send the same Jev question; they differ in where the logic lives and how results get back into the base. The table compares workflow shape, not accuracy, and no row is a benchmark.

Paste the script into the Run a script action and rename the table, fields, and label definitions to match your base. The request follows the documented JevModel contract: POST /api/v1/systemone with a Bearer key from a verified account, a state, and named questions, here one Choice called category; a successful response has code 0 and data.answers. There is no model field because the site always calls typesafe/jev-1.13 through OpenRouter; JevModel is independent of TypeSafe AI, which develops Jev. The script sends only the text, not names, emails, or other columns. A single-select value is written as an object with a name, and that option must already exist in the field. Records under the placeholder threshold, records labeled other, and failed calls get Needs review ticked, so a view filtered on that checkbox becomes the human queue. 0.7 is a placeholder; choose your own threshold from a labeled sample.

// Illustrative only. Airtable automation → "Run a script" action.
// Input variables: recordId (Airtable record ID from the trigger), text (the long-text field).
// Secret: JEVMODEL_API_KEY (Secrets tab in the script editor).
// Fields: Category (single select), Confidence (number), Needs review (checkbox).
const { recordId, text } = input.config();
const table = base.getTable("Requests");

const res = await fetch("https://jevmodel.app/api/v1/systemone", {
  method: "POST",
  headers: {
    Authorization: "Bearer " + input.secret("JEVMODEL_API_KEY"),
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    // The whole request must stay within 8,000 characters.
    state: { text: String(text || "").slice(0, 6000) },
    questions: {
      category: {
        type: "choice",
        instructions: "Which team should handle this request submitted through our form?",
        criteria: {
          billing: "Invoices, payments, refunds, or plan changes.",
          bug: "Something is broken, shows an error, or behaves unexpectedly.",
          feature_request: "Asks for something the product does not do yet.",
          other: "Anything that fits none of the labels above.",
        },
      },
    },
  }),
});
const out = await res.json();

if (out.code !== 0) {
  // Leave Category empty and hand the record to a person.
  await table.updateRecordAsync(recordId, { "Needs review": true });
  console.log("Jev call failed: " + out.message);
} else {
  const { choice, probabilities } = out.data.answers.category;
  const p = probabilities ? probabilities[choice] : 0;
  await table.updateRecordAsync(recordId, {
    Category: { name: choice }, // the option must already exist in the field
    Confidence: p,
    "Needs review": p < 0.7 || choice === "other", // 0.7 is a placeholder
  });
}

Start with records whose category a person already knows. Export a few hundred of them as CSV with the text and the human label, upload the text to JevModel Console → Batch with the same Choice question, and export the row-level answers. Then compare the two columns per label in a spreadsheet; Batch does not compute accuracy for you. Look at which pairs get confused and how agreement changes as you raise the probability cut-off, rewrite vague definitions, and rerun the same sample before you switch the automation on. The same CSV path is the simplest way to label a backlog: the automation only fires for records that newly match its conditions, and a script that loops over many records in one run hits the 50-fetch limit quickly. After launch, keep a view filtered on Needs review, sort by Confidence, and check the share of other each week; a growing share means the list of categories no longer matches what people submit. Never let a label delete, hide, or email anything until you have measured how often it is wrong, and keep the label field editable so people can correct it.

Choose the Run a script action when the base is where the work happens, you can edit a short script, and your plan includes the action. Choose a no-code tool when it already runs your other automations or the same text must also reach Slack, email, or a CRM; the Zapier, Make, n8n, Power Automate, and Pipedream guides show the same Jev request in each tool. Choose CSV plus Console → Batch for a one-off backlog or for testing label definitions before any automation exists. If your data lives in Google Sheets rather than Airtable, the Google Sheets guide covers the same pattern with Apps Script. Checklist for any of them: 1) write label definitions with an explicit other; 2) keep urgency as a separate yes/no question; 3) send the text only and cut it below the 8,000-character request limit; 4) leave the category empty and flag the record when a call fails; 5) start with labels and a review view, and add downstream actions only after you have measured agreement on a labeled sample. JevModel is text-only and is not open source; attachments, images, and audio in Airtable are not classified by this setup.