Airtable MCP

Airtable runs its own hosted MCP server at https://mcp.airtable.com/mcp. It lets an agent list bases, read and write records, change table schemas, build interfaces and forms, and draft automations, all within the permissions you already have. Sign-in is OAuth, or a personal access token for scripts. Airtable says there is no extra charge. We checked the docs on 31 October 2026.

Quick facts

Two things share the name. The first is Airtable's hosted server. The second is a popular community server that runs on your machine. We cover both, and we put the official one first because it has more features and is maintained by the vendor.

What it does

Airtable describes the server as a way to "connect AI tools directly to your Airtable bases" so you can ask questions about data, create and update records, build and manage automations and analyze information. The help center lists what that means in practice:

• Search and analyze data in bases you have allowed.
• Create and update records, in batches of up to 10 records when creating.
• Create bases, tables and fields.
• Read interface pages for users who have interface-only access.
• Create interfaces, interface pages and custom elements.
• Build forms and submit forms on your behalf.
• Draft and edit automations, and delete automations that are off.

Permissions mirror your own. Base owners and creators can change schema and records. Editors can change records. Commenters and read-only users can read. Interface-only users can use only what their interfaces expose. The agent cannot do more than you can.

The tools

Airtable's tools reference lists 40 tools. They fall into groups:

Two details stand out. revert_action exists, which suggests Airtable expects agents to make mistakes and gives them an undo. And create_automation saves a draft only. The automation stays off until a person reviews it and turns it on in Airtable. That is a good safety design.

Tool names, behaviors and capabilities "may change", according to the help center. Do not hard-code them in scripts.

What it costs

Airtable's help center answers this directly: "No. The MCP integration is currently included with your current Airtable plan." The server is available to all plans. Two limits still bite:

• MCP uses the public API under the hood, so calls count against API rate limits. Airtable's rate-limit page sets 5 requests per second per base and 50 requests per second per user or service account token, and a 429 response blocks requests for 30 seconds.
• Records you create count against your base limits.

Creating records is capped at 10 per request, a point to remember when you ask an agent to import a spreadsheet. It will loop, which takes time and many calls.

Install it

Airtable's own docs cover Claude, Claude Code, ChatGPT, Google Gemini and Cursor, plus a generic page for other clients. All use the same URL.

Option 1: OAuth

This is the default. Your client registers itself through dynamic client registration, opens a browser, and you pick which bases, interfaces or workspaces to share. You can choose everything you have access to, or custom access to specific ones. You can change this later in your third-party integration settings without starting over.

Some organizations want one allow-listable app instead. In that case register an OAuth integration at airtable.com/create/oauth with the redirect URL your client uses and these scopes:

data.records:read
data.records:write
schema.bases:read
schema.bases:write
data.recordComments:read
data.recordComments:write
workspacesAndBases:read

Option 2: personal access token

Airtable recommends a PAT for CLI tools, scripts and server-side setups, because the boundaries are fixed when you create the token. Create one with the scopes above, store it in an environment variable such as AIRTABLE_PAT and send it in an Authorization header.

Install it in each agent

The Airtable docs document Claude Code and Cursor. For Codex, Antigravity and OpenCode the lines below are our adaptation from each agent's own MCP docs. See MCP clients for how fields differ.

Claude Code

Airtable recommends its plugin, which bundles the server and some skills:

claude plugin install airtable@claude-plugins-official

Then restart Claude Code, open /plugin, find Airtable MCP under the Installed tab and choose Authenticate. The manual route from the help center:

claude mcp add --transport http airtable https://mcp.airtable.com/mcp

Then run /mcp in Claude Code to authenticate in the browser. With a PAT, add a header instead, as Airtable's generic page shows for JSON clients.

Cursor

Airtable offers an install deep link. The manual entry goes in ~/.cursor/mcp.json or .cursor/mcp.json:

{
  "mcpServers": {
    "airtable": {
      "type": "http",
      "url": "https://mcp.airtable.com/mcp"
    }
  }
}

The Airtable page shows the key as server in one place. We used airtable. Cursor's redirect for a static OAuth client is cursor://anysphere.cursor-mcp/oauth/callback.

Codex

Our adaptation, in ~/.codex/config.toml, using a PAT from the environment:

[mcp_servers.airtable]
url = "https://mcp.airtable.com/mcp"
bearer_token_env_var = "AIRTABLE_PAT"

Codex's MCP docs list bearer_token_env_var as the field that holds the name of the environment variable sent as a bearer token.

Antigravity

Our adaptation. In ~/.gemini/config/mcp_config.json, under mcpServers, use serverUrl:

{
  "mcpServers": {
    "airtable": {
      "serverUrl": "https://mcp.airtable.com/mcp",
      "headers": { "Authorization": "Bearer <AIRTABLE_PAT>" }
    }
  }
}

Antigravity's MCP docs accept a headers object for custom HTTP headers such as a bearer token. Airtable's Google Gemini quickstart covers the Gemini app, not Antigravity. Gemini CLI is now Code Assist enterprise only.

OpenCode

Our adaptation, in opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "airtable": {
      "type": "remote",
      "url": "https://mcp.airtable.com/mcp",
      "headers": { "Authorization": "Bearer {env:AIRTABLE_PAT}" }
    }
  }
}

The community server

domdomegg/airtable-mcp-server is an MIT-licensed TypeScript server with 456 GitHub stars when we checked, last pushed 25 Oct 2026. It runs locally over stdio with npx -y airtable-mcp-server and needs a PAT in AIRTABLE_API_KEY. The README asks for the scopes schema.bases:read and data.records:read, and optionally the write and comment scopes.

Its tools are list_records, search_records, list_bases, list_tables, describe_table, get_record, create_record, update_records, delete_records, create_table, update_table, create_field, update_field, create_comment and list_comments.

It also has an HTTP mode, MCP_TRANSPORT=http PORT=3000 npx airtable-mcp-server, and the README warns about it. That mode has no built-in authentication, and "a malicious website can use DNS rebinding" to reach localhost:3000/mcp and use your token to read, write and delete records. Stick to stdio on one machine.

Controls and security notes

Airtable's controls page is clear and worth reading before rollout.

• Scoping. With OAuth you choose bases at consent time. With a PAT you pick scopes and resources at creation.
• Read-only. Omit data.records:write and schema.bases:write. The server also enforces your existing permissions.
• Audit. Revision history on a record shows who made the change, meaning the user who authorized MCP, and which entity did it, the name of the OAuth app or PAT.
• Admin block. Enterprise Scale admins can switch on "Block MCP access" in the Admin Panel under Integrations and development. It beats any allowlist.
• Allowlisting. If third-party integrations are blocked, admins can allow specific OAuth client IDs. Airtable lists IDs for Claude Code, Claude.ai, ChatGPT, Amazon Quick, Google Gemini and Gemini Enterprise.
• Privacy. Airtable says the server sees only the structured arguments of each tool call, not your prompt, and does not store prompt context or conversation history. MCP activity follows the same retention as the REST API.
• Prompt injection. Records can hold text written by others. An agent that reads a hostile cell and then writes elsewhere is a risk. Use a read-only token for analysis and approval prompts for writes.
• Revoking. Go to your profile, Integrations, Third-party integrations, and remove bases or delete the integration.

Limits and known issues

• Airtable lists these limits: creating records is capped at 10 per request. Calls go through normal API rate limits. Automations that contain a Script action cannot be created or edited through MCP. Turning an automation on happens in the UI. MCP cannot add filters to an interface, such as a Current User filter. It cannot edit an interface that already exists, so you recreate it or edit by hand.
• Development bases for managed apps return a 403. Installed child bases work.
• Interface-only users can read through the interface tools but cannot reach base-level data.
• The official CLI is experimental and may change tool names without notice.
• We did not read the community repository's issue tracker for this page.

Alternatives

Example prompts and what to expect

Airtable's help center suggests prompts that show the range. Here is how we would read the effort and risk of each.

Airtable notes that it is normal for the agent to run discovery calls first. It may list bases, read a schema and sample records before it answers. If you name the base and describe the table, you save a few of those calls.

Which agents it suits

Claude and Claude Code have the most direct route, with a plugin that bundles skills. Cursor has a deep link. ChatGPT and Gemini have connectors for chat use. Codex, Antigravity and OpenCode work through the generic HTTP route, which Airtable documents for any client that speaks Streamable HTTP. If your agent handles remote OAuth well, use OAuth. If it does not, use a PAT with narrow scopes.

Our take

Airtable has made this easy to adopt safely. The server is hosted, free with your plan, permission-aware, and the docs explain scopes, read-only setup, revision history and admin blocks in plain terms. Drafts that stay off until a human enables them are a good call for automations.

The practical risk is bulk work. A 10-record cap and API rate limits mean an agent importing a large table will be slow and chatty. For big data loads, use Airtable's import tools or its API directly, and use the agent for schema and analysis.

If you only need a quick local server for one base, the community project is simple and well liked, but it is one developer's project and has fewer features. This is our reading of the documentation, not a hands-on test.

A short setup checklist

1. Check whether your organization blocks third-party integrations.
2. Pick OAuth for a person, a PAT for a script.
3. Start read-only by omitting the write scopes.
4. Share only the bases the task needs.
5. Add the server to your agent and authenticate.
6. Test with a question about one table.
7. Turn on write scopes only for a base you can back up.
8. Check record revision history after the first write.

See also the MCP server list and best MCP servers.

Frequently asked questions

What is the Airtable MCP server URL?

https://mcp.airtable.com/mcp, over Streamable HTTP, for all plans.

Does the Airtable MCP server cost extra?

Not according to Airtable. Rate limits and base limits still apply.

How do I make it read-only?

Leave out the two write scopes when you create a PAT or approve OAuth.

Is there an open-source Airtable MCP server?

Yes, domdomegg/airtable-mcp-server under MIT, and Airtable's own CLI under MIT.

Can the agent switch on an automation?

No. It can draft and edit, but you turn it on in Airtable.