# How to connect Airtable to Hermes Agent (no API keys)

> Connect Airtable to Hermes with ClawLink in one click — 23 tools your AI agent can call from chat via hosted OAuth. No API keys, no manual setup.

Web version: https://claw-link.dev/hermes/airtable

Most guides for giving Hermes Agent Airtable access start with registering your own OAuth app or pasting API keys into env files, then leave the token refresh and tool wiring to you. ClawLink gives Hermes a more practical Airtable setup: pair once in the browser and your always-on Hermes agent can act on Airtable for you, reading and doing real work on your behalf with no auth, token refresh, or tool wiring to build yourself.

**Start here — paste this into Hermes to set up ClawLink:**

> Set up ClawLink for Hermes and tell me when it's ready.
> 1. Install the plugin: `hermes plugins install ClawLink-HQ/hermes-plugin --enable`
> 2. Start pairing with `hermes clawlink begin`. It prints an approval link, so show me the link and stop, don't wait.
> 3. I'll approve it in my browser, then reply "approved".
> 4. When I say approved, finish setup: `hermes clawlink finish`
> 5. Then run `hermes clawlink test` and tell me whether ClawLink is ready.

## Setup

It takes three steps to connect Hermes to Airtable.

1. **Install ClawLink** — add the plugin to Hermes Agent once.
2. **Connect Airtable** — one-click OAuth in the ClawLink dashboard.
3. **Use it from chat** — ask Hermes Agent in plain English.

**Alternative for any agent (no plugin needed):** if the Hermes Agent plugin route isn't available or doesn't work, any AI agent with shell access can use the ClawLink CLI instead:

```bash
npx -y @useclawlink/cli login          # sign in via browser — no API key to paste
npx -y @useclawlink/cli connect airtable  # connect Airtable (browser OAuth)
npx -y @useclawlink/cli actions airtable  # list available actions
npx -y @useclawlink/cli run airtable <action> --input '<json>'  # execute (add --confirm for writes)
```

### Install by command

The prompt above walks Hermes through this. By hand, it is four commands and a browser approval:

```bash
hermes plugins install ClawLink-HQ/hermes-plugin --enable
hermes clawlink begin    # prints an approval link — open it and approve
hermes clawlink finish   # after approving in the browser
hermes clawlink test
```

Then connect Airtable in the [ClawLink dashboard](https://claw-link.dev/dashboard) — a one-click OAuth approval, no API keys.

Verify the connection by asking Hermes:

> Call airtable_list_bases, pick the base I name, then call airtable_get_base_schema for the table, then airtable_list_records (baseId, tableIdOrName, pageSize 100) and follow the offset until all records are returned. Show me the first 20.

### Using a different agent?

The Hermes plugin is one client of ClawLink's MCP server. Claude Code, Cursor, Codex, or any agent that can run a shell command pairs with the same ClawLink account through the CLI:

```bash
npx -y @useclawlink/cli login
```

`login` opens the same browser approval and stores a credential locally. Once Airtable is connected in the dashboard, that agent calls the same 23 Airtable tools over MCP. Full setup for MCP clients and shell agents: [connect apps to any AI agent](https://claw-link.dev/learn/connect-apps-to-any-ai-agent).

## Airtable MCP for Hermes

Looking for a Airtable MCP server for Hermes Agent? ClawLink connects Airtable to Hermes Agent and exposes 23 Airtable tools your agent can call over [MCP](https://claw-link.dev/learn/what-is-an-mcp-server), with [hosted auth](https://claw-link.dev/learn/oauth-for-ai-agents) and nothing to run or maintain yourself. Using OpenClaw instead? The [OpenClaw Airtable integration](https://claw-link.dev/openclaw/airtable) works the same way.

The setup ChatGPT teaches for Airtable is a personal access token: generate one at airtable.com/create/tokens, save it as `AIRTABLE_API_KEY`, and hand it to Hermes. Airtable's own docs make a point that undercuts that route: personal access tokens "act as your user account, and should not be shared with third-party services or integrations", and legacy API keys stopped working after the deprecation period ended on February 1 2024. For an external service using your account, Airtable says it plainly: use OAuth. That is this route: connect once in the browser, approve the bases the agent may touch, and the 23 tools below work from Hermes chat with no token generated, stored, or pasted anywhere.

## What the Hermes Agent Airtable integration can do

23 Airtable tools are ready for Hermes Agent once the account is connected. The 20 below are the ones people reach for most; your agent can call all 23.

### 20 of 23 Airtable tools for Hermes

| Tool | What it does |
|---|---|
| **Create comment** `airtable_create_comment` | Create a comment on an Airtable record |
| **Create field** `airtable_create_field` | Create a field in an Airtable table |
| **Create table** `airtable_create_table` | Create a new Airtable table |
| **Get record** `airtable_get_record` | Get a specific Airtable record |
| **List bases** `airtable_list_bases` | List Airtable bases available to the connected account |
| **List records** `airtable_list_records` | List records in an Airtable table |
| **Update comment** `airtable_update_comment` | Update a comment on an Airtable record |
| **Update field** `airtable_update_field` | Update a field in an Airtable table |
| **Update table** `airtable_update_table` | Update an Airtable table |
| **Get base schema** `airtable_get_base_schema` | Retrieves the detailed schema for a specified Airtable base, including its tables, fields |
| **Get user info** `airtable_get_user_info` | Retrieves information, such as ID and permission scopes, for the currently authenticated |
| **List comments** `airtable_list_comments` | List comments on a specific Airtable record |
| **Create base** `airtable_create_base` | Creates a new Airtable base with specified tables and fields within a workspace |
| **Create record from natural language** `airtable_create_record_from_natural_language` | Creates a new record in an Airtable table from a natural language description |
| **Create records** `airtable_create_records` | Create multiple records (up to 10) in a specified Airtable table |
| **Update multiple records** `airtable_update_multiple_records` | Update up to 10 records in an Airtable table with selective field modifications |
| **Update multiple records put** `airtable_update_multiple_records_put` | Destructively update multiple records in Airtable using PUT, clearing unspecified fields |
| **Update record** `airtable_update_record` | Modifies specified fields of an existing record in an Airtable base and table; the base, table |
| **Update record put** `airtable_update_record_put` | Updates an existing record in an Airtable base using PUT method |
| **Upload attachment** `airtable_upload_attachment` | Uploads a file attachment to a specified field in an Airtable record |

## Example prompts

**List records with pagination**

> Call airtable_list_bases, pick the base I name, then call airtable_get_base_schema for the table, then airtable_list_records (baseId, tableIdOrName, pageSize 100) and follow the offset until all records are returned. Show me the first 20.

**Create records in bulk**

> Create the 25 rows from the attached CSV in the Leads table with airtable_create_records, batching 10 records per call, typecast true. Confirm the first batch's field mapping against the schema before sending.

**Summarize a base schema**

> Call airtable_get_base_schema for the base I name and summarize every table with its field names, types, and counts.

**Update a record**

> Find the record in the Leads table whose Company field is "Acme", show me its record id and current fields, then update its Status field to "contacted" and confirm the change.

## Airtable tool arguments that trip agents up

Verified 2026-08-02 against the live Composio schemas (backend.composio.dev/api/v3.1/tools/\) and Airtable's API docs. These are the traps in the current toolset, with the prod error counts attached:

- `airtable_list_records` requires `baseId` and `tableIdOrName`. `baseId` must start with `app` followed by 14 characters (so a bare workspace URL does not work). `pageSize` is capped at 100 (default 100), and pagination is by `offset` token, not by page number. The sort array rejects system fields like `createdTime`; sorting by them is the second most common Airtable error on ClawLink (38 recorded).
- `airtable_create_records` requires `baseId`, `tableIdOrName`, and `records`, and accepts up to 10 records per call. `typecast` (default false) makes Airtable convert string values to the field types it can; without it, a string in a number field fails validation.
- `airtable_list_bases` takes no required arguments and returns only the bases the connection was granted at connect time, with an `offset` for pagination. If a base is missing from its output, the grant does not cover it.
- Field names are case-sensitive and must match the table schema exactly, including spaces. `airtable_get_base_schema` returns the real names and field IDs (like `fldGS8DOfrvvszR4a`); use it before any write, or the unknown-field-name family of errors is what you get (15+ recorded).
- INVALID_PERMISSIONS_OR_MODEL_NOT_FOUND (7 recorded) means the user, the token, or the grant cannot reach the requested base, table, or record: not a collaborator, read-only role, or a base the OAuth grant was never scoped to. It is not a ClawLink error.
- `airtable_create_record_from_natural_language` exists for plain-language record creation; the schema-backed create tools remain the reliable path for bulk or exact work.

## ClawLink vs. building it yourself

The alternative to ClawLink is usually manual OAuth app setup plus your own token handling, permission troubleshooting, and tool plumbing for Hermes Agent. That is fine if you want to build and maintain the integration yourself. Most teams just want Airtable working from chat.

| | Manual | ClawLink |
|---|---|---|
| **Connection flow** | Register a Airtable app, configure redirect URLs, manage consent details, and reconnect users when auth settings drift. | Users connect Airtable through the hosted browser flow and ClawLink keeps the token lifecycle out of your app code. |
| **Ongoing maintenance** | You own refresh logic, permission debugging, environment config, and every provider-specific edge case for Airtable. | ClawLink handles the repetitive integration plumbing so your team can focus on the workflow instead of the infrastructure. |
| **Agent usability** | You still need to expose the right Airtable actions to the runtime in a format your agent can reliably use. | 23 tools for Airtable are already exposed through ClawLink, so the agent can read and act from chat immediately. |

## ClawLink vs. Composio

Composio also exposes Airtable to AI agents. It is developer infrastructure: Python and TypeScript SDKs, an MCP server, and a catalog past 1,000 apps, aimed at teams shipping agent products. ClawLink is built for Hermes Agent users instead. You install the plugin once, connect Airtable in the browser, and the 23 tools above work from chat. There is no SDK, no config file, and no API key handling. Choosing between them? Read the full [Composio alternatives](https://claw-link.dev/hub/composio-alternatives) comparison.

### Hermes paired but still can't use Airtable
Pairing is a two-step handshake: run `hermes clawlink begin`, approve the link in your browser, then run `hermes clawlink finish`. If you ran finish before approving, or the approval link expired, run `hermes clawlink begin` again to get a fresh link. Confirm the plugin was installed with `--enable`, then verify with `hermes clawlink test`.

### Connection succeeds but no tools appear
Reconnect Airtable from the dashboard, then start a fresh chat if the runtime still has the old tool catalog loaded.

### "Tool schema not loaded yet" error when calling Airtable tools
Airtable tool schemas load on demand the first time a tool runs and are cached after that, so this error usually clears on its own: wait a few seconds and retry the same request. If every Airtable call keeps failing with it in a fresh chat, reconnect from the dashboard, and contact support if it still persists — that pattern points to a configuration problem on our side, not something you can fix by reconnecting again.

### Airtable returns 403 or "permission denied" on one action while others work
Two usual causes. The connected account may not have access to the specific workspace, inbox, store, or project in the request — check that first. If access looks right, the agent may have sent a placeholder value (like "YOUR_ID" or an example id from documentation) instead of a real one: ask it to run a list or search tool first, then retry the action with a real id from those results. Most failures at this stage are one of these two, not ClawLink bugs.

### arguments.tableIdOrName is required
The most common Airtable failure on ClawLink, and it is an argument error: the agent called a records tool without the table reference. Every records call needs `baseId` and `tableIdOrName` (the table's name or its ID). Ask the agent to run airtable_get_base_schema for the base and use a real table name from the result. `arguments.baseId is required` (the second most common variant) is the same failure one level up: run airtable_list_bases and use a real base ID from it.

Ask the agent to diagnose it:

```text
Run airtable_list_bases and airtable_get_base_schema, show me the real base IDs and table names, then retry the failing call with them.
```

### Cannot sort by system metadata field 'Created At'
Airtable's sort parameter rejects system fields: sorting by `Created At` (or `createdTime`, `lastModifiedTime`, or `id`) returns a value error naming the field, because those columns are not sort keys. The D1 record shows the exact phrasing: "Cannot sort by system metadata field 'Created At'. System fields like 'createdTime', 'lastModifiedTime', and 'id' are not sortable." Ask the agent to sort on a real field from the schema, or drop the sort and paginate instead.

Ask the agent to diagnose it:

```text
List the sortable fields from airtable_get_base_schema, then retry with a sort on a real field, not Created At.
```

### Unknown field name: "Drehbericht". Field names in Airtable are case-sensitive and must match exactly as they appear in the table
Airtable field names are exact: case-sensitive, spaces included. Passing a name that differs by a letter or case (or a stale field that was renamed) returns this error with the offending name quoted. The fix is to stop guessing and read the schema: airtable_get_base_schema returns the real field names and IDs for the table. Field IDs (strings like `fldGS8DOfrvvszR4a`) are also accepted and appear in the schema output; if the agent has an ID it can use that instead of the name.

Ask the agent to diagnose it:

```text
Call airtable_get_base_schema and show me the exact field names for the table. Then retry using names copied from that output.
```

### Airtable API error (INVALID_PERMISSIONS_OR_MODEL_NOT_FOUND): Invalid permissions, or the requested model was not found
Airtable's combined permissions/model error: either the user, the token, or the OAuth grant does not have access to the base, table, or record in the request. The usual causes in prod: the account is not a collaborator on the base, the OAuth grant was scoped to different bases at connect time, the account holds a read-only role on the table, or the base ID is wrong. Run airtable_list_bases to see which bases the connection can reach; if the target base is not listed, the grant needs re-scoping, so reconnect and approve the base. If it is listed, check your role on the table in Airtable.

Ask the agent to diagnose it:

```text
Run airtable_list_bases and tell me whether the failing base is in the list. If it is not, I will reconnect and grant it. If it is, check my permission role on the table.
```

### Too many requests. Try again shortly.
An Airtable rate limit, and the third most common Airtable error on ClawLink (8 recorded). Airtable allows 5 requests per second per base and 50 per second for all traffic from one user, and asks you to wait 30 seconds after a 429 before retrying. Agents that loop over a table row-by-row hit this fast; the fix is batching (up to 10 records per airtable_create_records call) and a pause between pages.

Ask the agent to diagnose it:

```text
Stop and wait 30 seconds. Then continue the remaining records in batches of 10 with airtable_create_records, waiting between batches.
```

### Tool 'airtable_get_records' not found. Did you mean: 'airtable_get_record', 'airtable_create_records', 'airtable_delete_multiple_records'?
A guessed tool name: there is no `airtable_get_records`, `airtable_update_records`, or `airtable_find_records`. The real tools are `airtable_list_records`, `airtable_update_record` / `airtable_update_multiple_records`, and `airtable_get_record` (single record by ID). ClawLink returns a "Did you mean" line on every miss; ask the agent to read it and retry with the suggested name, or list the Airtable catalog first and pick from it.

Ask the agent to diagnose it:

```text
List the available Airtable tools, show me the exact names, and retry with the real one.
```

### OAuth finished in the browser but the account is still missing
Try reconnecting Airtable and complete the consent flow in the same browser session. Partial OAuth approvals or switching accounts mid-flow can leave the connection incomplete.

### Is there a Hermes Agent Airtable integration?
Yes. ClawLink is the fastest way to connect Hermes to Airtable: link your Airtable account once in the browser and Hermes Agent can call the Airtable API through 23 ready-made tools — no custom code or token handling.

### How do I connect Airtable to Hermes with ClawLink?
Install the plugin with `hermes plugins install ClawLink-HQ/hermes-plugin --enable`, then pair once: run `hermes clawlink begin`, approve the link in your browser, and run `hermes clawlink finish`. Connect Airtable in the dashboard and Hermes can use it from the next message — no config files or API keys to manage.

### How long does it take to connect Airtable to Hermes Agent?
About two minutes. Sign in, click Connect next to Airtable in the dashboard, authenticate, and Hermes Agent can use it from the next chat message.

### Why use ClawLink instead of wiring Airtable up myself?
The alternative to ClawLink is usually manual OAuth app setup plus your own token handling, permission troubleshooting, and tool plumbing for Hermes Agent. That is fine if you want to build and maintain the integration yourself. Most teams just want Airtable working from chat.

### Do I need an Airtable personal access token for this?
No. The hosted connection is OAuth, which is the flow Airtable's authentication docs recommend for third-party integrations that act on a user's behalf. A personal access token acts as your user account and Airtable explicitly advises against sharing it with third-party services. Legacy API keys are not an option anymore: the deprecation period ended February 1 2024, and the API accepts only personal access tokens and OAuth tokens. With OAuth, the tokens live on the ClawLink side and you can revoke the grant from your Airtable account anytime.

### Which bases can Hermes access?
The ones you approve during the connection, and only those. In Airtable's OAuth flow the end user decides which resources to grant access to, and the connection can only list and use the bases it was granted. A tool call against a base you did not approve, or a base you are not a collaborator on, fails with Airtable's INVALID_PERMISSIONS_OR_MODEL_NOT_FOUND error rather than succeeding silently. Run airtable_list_bases first to see exactly which bases the connection can reach.

### How fast can the agent write to Airtable?
Airtable limits the API to 5 requests per second per base and 50 requests per second for all traffic from one user's tokens. Exceeding it returns HTTP 429 and Airtable asks you to wait 30 seconds before retrying. The tools on this page carry the same limits as any Airtable API client, so an agent bulk-loading records should batch them into create calls (up to 10 records each) rather than firing one-by-one.

### Is it safe to connect Airtable to an AI agent?
The connection is an OAuth grant with Airtable's standard scopes (record read/write, schema read, base listing), and you control the blast radius two ways: which bases you approve at connect time, and revocation, which is immediate from your Airtable account settings. Inside those bounds, the agent can read and write records in the granted bases, which is the same access a PAT would give but without a long-lived secret sitting in a config file. Airtable's scopes reference (data.records:write and similar) is the exact list of what the grant can do.

### Hermes paired but still can't use Airtable
Pairing is a two-step handshake: run `hermes clawlink begin`, approve the link in your browser, then run `hermes clawlink finish`. If you ran finish before approving, or the approval link expired, run `hermes clawlink begin` again to get a fresh link. Confirm the plugin was installed with `--enable`, then verify with `hermes clawlink test`.

## Related

- [Hermes DocuSign integration](https://claw-link.dev/hermes/docusign) — Send, sign, and manage agreements and envelopes
- [Connect Moco](https://claw-link.dev/hermes/moco) — MOCO is a business management software offering project management, time tracking, and invoicing solutions.
- [Wrike](https://claw-link.dev/hermes/wrike) — Manage projects, tasks, and team workflows at scale