Google Sheets Text Classification: the =AI() Function vs Apps Script → Jev API

Most spreadsheet classification jobs have the same shape: one column of free text (survey answers, form submissions, support messages, product reviews), a short list of categories, and a new column that should hold exactly one of those categories per row. The useful extras are a confidence column, a “needs review” flag, and a column of hand labels on a sample so you can check the result. In Google Sheets there are three realistic ways to fill that label column: the built-in AI function, an Apps Script that calls an external classification API such as JevModel, or exporting a CSV, classifying it elsewhere, and pasting the results back.

Google’s help page describes the syntax AI("prompt", [optional range]); =Gemini() is an equivalent name. You select the cells and click Generate and Insert, and Refresh and Insert when you want new output. Google’s own examples include categorizing a customer inquiry as a compliment, exchange request, or return request, and classifying email bodies as positive, negative, or neutral. Documented limits matter for classification: responses are text only; the function sees only the range you pass, not the whole spreadsheet; it cannot be embedded in another formula (Google’s example of an unsupported pattern wraps AI() in IF); only the first 350 selected AI cells are generated at a time; there are short- and long-term generation limits; and access depends on your plan, admin settings, and language. Strengths: zero setup for eligible accounts and a natural-language prompt that non-developers can edit. Limits: the output is free text, so a label can drift (“Return”, “return request”, “Returns”) unless your prompt and a cleanup step force exact values, and there is no per-label probability column to drive a review threshold.

Apps Script can call any HTTPS API with UrlFetchApp, and Google’s custom-function guide confirms that URL Fetch is one of the services a custom function may use. It is still the wrong place for a metered classification call. A custom function must return within 30 seconds or the cell shows #ERROR!; each use is a separate call to the Apps Script server; and the function recalculates whenever a referenced cell changes, so an edit can quietly classify (and pay for) the same row again. A custom menu item avoids that: the script runs once when you click it, reads the selected rows, calls JevModel, and writes the label and probability as plain values that never recalculate. Plan for Google’s published limits: 6 minutes per script execution, and URL Fetch quotas of 20,000 calls/day for consumer accounts and 100,000/day for Google Workspace accounts (Google notes these can change). Work in selections small enough to finish inside one execution. Store the JevModel key in Project Settings → Script properties rather than in a cell, and remember that anyone who can edit the spreadsheet can also edit its bound script, so keep the editor list short.

The table compares workflow shape and output contract, not accuracy. No row here is a benchmark; measure on your own labeled sample.

Open Extensions → Apps Script, paste the code, add a script property named JEVMODEL_API_KEY with a key from JevModel Console → API keys, and reload the sheet. Select the text cells in one column and choose Jev → Classify selected rows; the label and its probability are written into the next two columns. The request follows the documented contract: a state (the cell text) plus named questions, here one Choice whose criteria map label IDs to short definitions. Clear definitions, including an explicit “other”, matter more than clever wording. The site fixes the model to typesafe/jev-1.13 through OpenRouter, so there is no model field. JevModel is independent of TypeSafe AI, which develops Jev. A non-zero code (for example INSUFFICIENT_TOKENS) is written as ERROR so you can rerun only those rows; the API has no idempotency key, so do not rerun rows that already have a label.

// Illustrative only. Save the key as the script property JEVMODEL_API_KEY.
// Run from the menu, not as a custom function, so edits never re-bill rows.
const LABELS = {
  billing: "Charges, refunds, invoices or payment methods.",
  shipping: "Delivery status, delays or address changes.",
  product: "How the product works, or a defect report.",
  other: "Anything that fits none of the labels above.",
};

function onOpen() {
  SpreadsheetApp.getUi()
    .createMenu("Jev")
    .addItem("Classify selected rows", "classifySelection")
    .addToUi();
}

function classifySelection() {
  const key = PropertiesService.getScriptProperties().getProperty("JEVMODEL_API_KEY");
  const sheet = SpreadsheetApp.getActiveSheet();
  const range = sheet.getActiveRange(); // one column of text cells
  const rows = range.getValues().map(([text]) => {
    if (!text) return ["", ""];
    const res = UrlFetchApp.fetch("https://jevmodel.app/api/v1/systemone", {
      method: "post",
      contentType: "application/json",
      headers: { Authorization: "Bearer " + key },
      muteHttpExceptions: true,
      payload: JSON.stringify({
        state: String(text),
        questions: {
          route: {
            type: "choice",
            instructions: "Which support queue should handle this message?",
            criteria: LABELS,
          },
        },
      }),
    });
    const body = JSON.parse(res.getContentText());
    if (body.code !== 0) return ["ERROR", body.message];
    const answer = body.data.answers.route;
    const p = answer.probabilities ? answer.probabilities[answer.choice] : "";
    return [answer.choice, p];
  });
  // Plain values in the next two columns: label, probability.
  sheet.getRange(range.getRow(), range.getColumn() + 1, rows.length, 2).setValues(rows);
}

Spreadsheets make evaluation easy, so do it. Before classifying the whole sheet, hand-label a random sample of rows in a separate column, run the same question on them, and compare with a COUNTIFS or a pivot table: agreement per label, and which labels get confused. Then pick a review rule from that sample, for example “probability below the level where most disagreements happened goes to review”, and add a formula column such as =IF(C2<0.7,"review","ok"); 0.7 is a placeholder, not a recommendation. Keep the “other” label and treat a high share of “other” as a sign the label list needs work, not as model failure. The Choice confidence TypeSafe describes, (p − 1/n)/(1 − 1/n), adjusts for the number of labels but is not calibrated accuracy either. Re-check the sample after changing labels or definitions.

Pick =AI() when you already have an eligible plan, the sheet is a one-off exploration, and a person will read the results anyway. Pick the Apps Script → Jev menu when the same label set is reused, you want a probability column to decide what gets reviewed, or the labels must match what an automation elsewhere (Zapier, Make, n8n, Power Automate, Pipedream, or your own app) already uses through the same API. Pick CSV → Console → Batch when you want Jev labels without writing code, or to try a question on a small file first. Checklist for any path: 1) write label definitions with an explicit “other”; 2) hand-label a sample; 3) keep labels as values, not live formulas, once accepted; 4) keep API keys out of cells; 5) do not claim accuracy you have not measured on that sample. If one row can carry several labels, see multi-label-text-classification instead of forcing one Choice.