Airtable

The Airtable enables tools and to call Airtable APIs on behalf of a using OAuth 2.0 authentication.

Want to quickly get started with Airtable in your or AI app? The pre-built Arcade Airtable MCP Server is what you want!

What’s documented here

This page describes how to use and configure Airtable auth with Arcade.

This is used by:

The Arcade Airtable MCP Server, which provides pre-built for interacting with Airtable
Your app code that needs to call the Airtable API
Or, your custom tools that need to call the Airtable API

Use Arcade’s default Airtable auth provider

Arcade offers a default Airtable that you can use in the Arcade Cloud Platform. In this case, your will see Arcade as the name of the app requesting permission.

If you choose to use Arcade’s Airtable auth, you don’t need to configure anything. Follow the Airtable MCP Server examples to get started calling Airtable .

Configuring Airtable auth

When using your own app credentials, make sure you configure your to use a custom user verifier. Without this, your end-users will not be able to use your app or in production.

In a production environment, you will most likely want to use your own Airtable app credentials. This way, your will see your application’s name requesting permission.

Before showing how to configure your Airtable app credentials, let’s go through the steps to create an Airtable app.

Create an Airtable app

To integrate with Airtable’s API, you’ll need to create an OAuth integration:

Access the Airtable Developer Hub

Navigate to the Airtable Developer Hub and sign in with your Airtable .

Create a new OAuth integration

Go to the Create OAuth Integration page
Fill in the required details:
- Integration Name: Choose a descriptive name for your application
- Description: Provide a brief description of your app’s purpose

Configure OAuth settings

Set the Redirect URL to the redirect URL generated by Arcade (see configuration section below)
Configure the required Scopes for your application:
- data.records:read - Read records from tables
- data.records:write - Create, update, and delete records
- schema.bases:read - Read base schema
- user.email:read - Read the ’s email address
- Add other scopes as needed for your use case

Obtain your credentials

After creating your integration, you’ll receive a Client ID
Generate a Client Secret from your integration settings
Copy both values for use in Arcade configuration

For detailed instructions, refer to Airtable’s OAuth documentation.

Next, add the Airtable app to Arcade.

Configuring your own Airtable Auth Provider in Arcade

Dashboard GUI

Configure Airtable Auth Using the Arcade Dashboard GUI

To access the Arcade Cloud dashboard, go to api.arcade.dev/dashboard. If you are self-hosting, by default the dashboard will be available at http://localhost:9099/dashboard. Adjust the host and port number to match your environment.

Navigate to the OAuth Providers page

Under the Connections section of the Arcade Dashboard left-side menu, click OAuth providers.
Click Add OAuth Provider in the top right corner.
Select the Included Providers tab at the top.
In the Provider dropdown, select Airtable.

Enter the provider details

Choose a unique ID for your provider (e.g. “my-airtable-provider”).
Enter the Client ID and Client Secret from your Airtable integration.
Note the Redirect URI generated by Arcade. This must be set as your Airtable integration’s Redirect URL.
Optionally enter a Description.

Create the provider

Hit the Create button and the provider will be ready to be used.

Configuration File

Configure Airtable Auth Using Configuration File

This method is only available when you are self-hosting the engine

Set environment variables

Set the following environment variables:

export AIRTABLE_CLIENT_ID="<your client ID>"
export AIRTABLE_CLIENT_SECRET="<your client secret>"

Or, you can set these values in a .env file:

AIRTABLE_CLIENT_ID="<your client ID>"
AIRTABLE_CLIENT_SECRET="<your client secret>"

Edit the Engine configuration

Edit the engine.yaml file and add a new item to the auth.providers section:

auth:
  providers:
    - id: my-airtable-provider
      description: Airtable OAuth 2.0 provider
      enabled: true
      type: oauth2
      provider_id: airtable
      client_id: ${env:AIRTABLE_CLIENT_ID}
      client_secret: ${env:AIRTABLE_CLIENT_SECRET}

Setting provider_id: airtable applies the ’s built-in Airtable configuration (endpoints, PKCE, and token request settings), so you don’t need to specify them.

When you use tools that require Airtable auth using your Arcade credentials, Arcade will automatically use this Airtable OAuth provider. If you have multiple Airtable providers, see using multiple auth providers of the same type for more information.

Using Airtable auth in app code

Use the Airtable in your own and AI apps to get a token for the Airtable API. See authorizing agents with Arcade to understand how this works.

Use client.auth.start() to get a token for the Airtable API:

Python

from arcadepy import Arcade

client = Arcade()  # Automatically finds the `ARCADE_API_KEY` env variable

user_id = "{arcade_user_id}"

# Start the authorization process
auth_response = client.auth.start(
    user_id=user_id,
    provider="airtable",
    scopes=["data.records:read", "data.records:write", "schema.bases:read"]
)

if auth_response.status != "completed":
    print("Please complete the authorization challenge in your browser:")
    print(auth_response.url)

# Wait for the authorization to complete
auth_response = client.auth.wait_for_completion(auth_response)

token = auth_response.context.token
# Do something interesting with the token...

JavaScript

import { Arcade } from "@arcadeai/arcadejs";

const client = new Arcade();

const userId = "{arcade_user_id}";

// Start the authorization process
let authResponse = await client.auth.start(userId, "airtable", {
  scopes: ["data.records:read", "data.records:write", "schema.bases:read"],
});

if (authResponse.status !== "completed") {
  console.log("Please complete the authorization challenge in your browser:");
  console.log(authResponse.url);
}

// Wait for the authorization to complete
authResponse = await client.auth.waitForCompletion(authResponse);

const token = authResponse.context.token;
// Do something interesting with the token...

Using Airtable auth in custom tools

You can use the pre-built Arcade Airtable MCP Server to quickly build and AI apps that interact with Airtable.

If the pre-built tools in the Airtable Server don’t meet your needs, you can author your own custom tools that interact with the Airtable API.

Use the Airtable() auth class to specify that a requires authorization with Airtable. The context.authorization.token field will be automatically populated with the ’s Airtable token:

from typing import Annotated

import httpx
from arcade_mcp_server import Context, tool
from arcade_mcp_server.auth import Airtable


@tool(
    requires_auth=Airtable(
        scopes=["schema.bases:read"]
    )
)
async def list_bases(
    context: Context,
) -> Annotated[dict, "The user's bases."]:
    """
    Retrieve the list of bases accessible to the authenticated user.
    """
    url = "https://api.airtable.com/v0/meta/bases"
    headers = {
        "Authorization": f"Bearer {context.authorization.token}",
    }

    async with httpx.AsyncClient() as client:
        response = await client.get(url, headers=headers)
        response.raise_for_status()
        return dict(response.json())

Available Scopes

Airtable supports various OAuth scopes that determine the level of access your application has:

data.records:read - Read records from tables
data.records:write - Create, update, and delete records
data.recordComments:read - Read comments on records
data.recordComments:write - Create and update comments on records
schema.bases:read - Read base schema information
schema.bases:write - Modify base schema
webhook:manage - Create and manage webhooks
user.email:read - Read email address

For a complete list of available scopes, refer to the Airtable Scopes documentation.