Skip to main content
RapidDev - Software Development Agency
openclaw-integrationsDirect API Integration

How to Connect Airtable to OpenClaw

To connect OpenClaw to Airtable, store your AIRTABLE_API_KEY in OpenClaw's config and configure direct HTTP calls to the Airtable REST API. This is a Direct API integration — there is no ClawHub skill for Airtable. You set up the connection through OpenClaw's HTTP integration layer, which then allows reading, creating, updating, and deleting records from any Airtable base using structured API calls.

What you'll learn

  • How to generate an Airtable personal access token and store it in OpenClaw's config
  • How to find your Airtable base ID and table ID for API calls
  • How to read, create, update, and delete Airtable records through OpenClaw's HTTP integration
  • How to filter and sort records when querying from OpenClaw
  • How to handle Airtable's pagination for large tables
Book a free consultation
4.9Clutch rating
600+Happy partners
17+Countries served
190+Team members
Intermediate12 min read20 minutesProductivityMarch 2026RapidDev Engineering Team
TL;DR

To connect OpenClaw to Airtable, store your AIRTABLE_API_KEY in OpenClaw's config and configure direct HTTP calls to the Airtable REST API. This is a Direct API integration — there is no ClawHub skill for Airtable. You set up the connection through OpenClaw's HTTP integration layer, which then allows reading, creating, updating, and deleting records from any Airtable base using structured API calls.

Connect OpenClaw to Airtable's REST API

Airtable's REST API is one of the most developer-friendly APIs available for a productivity tool. Every base and table in Airtable is automatically available via REST endpoints, and the API supports the full range of CRUD operations with filtering, sorting, and pagination built in. The OpenClaw Direct API integration brings this power into OpenClaw's config-driven architecture: set your API key once, configure the base and table IDs you need, and OpenClaw can read from and write to Airtable as part of broader automation workflows.

The typical use case pattern is reading structured data from Airtable as context for OpenClaw actions — loading a content calendar, reading a contact list, checking inventory data — or writing results back to Airtable after processing. For example, an OpenClaw workflow might read pending tasks from an Airtable project tracker, process them, and update the status field when complete. Or it might pull a list of customers from an Airtable CRM and use the data to personalize outreach messages.

Airtable's API uses personal access tokens (PATs) for authentication — these replaced the older API key system in late 2023. PATs are scoped to specific permissions and bases, which is a security improvement over the previous global API key. The setup process involves creating a PAT in Airtable's developer settings with the appropriate scopes for the operations you need.

Integration method

Direct API Integration

Airtable integration uses the Airtable REST API directly from OpenClaw's HTTP integration layer. You store your AIRTABLE_API_KEY in OpenClaw's config and configure API call patterns for the Airtable endpoints you need. The integration supports full CRUD operations: listing records, creating records, updating records, deleting records, and querying with filters. Because this is a Direct API integration rather than a ClawHub skill, setup requires configuring HTTP request patterns rather than running an install command.

Prerequisites

  • OpenClaw installed and running (see openclaw.ai for installation instructions)
  • An Airtable account with at least one base containing data
  • Access to Airtable Developer Hub (airtable.com/create/tokens) to create a personal access token
  • Your Airtable base ID and table ID (found in the base URL or via the API documentation page)
  • Familiarity with REST APIs and JSON data structures

Step-by-step guide

1

Generate an Airtable Personal Access Token

Airtable uses personal access tokens (PATs) for API authentication. Unlike the older Airtable API key (which was global and granted access to all bases), PATs are scoped to specific permissions and optionally to specific bases. Navigate to airtable.com/create/tokens (or go to your Airtable account icon > Developer Hub > Personal access tokens). Click 'Create new token'. Give it a descriptive name like 'OpenClaw Integration'. Select the scopes you need. For read-only access, enable `data.records:read` and `schema.bases:read`. For full CRUD, also enable `data.records:write`. For accessing all bases on your account, select 'All workspaces and bases' under the Access section — or restrict to specific bases if you prefer tighter access control. Click 'Create token'. Airtable shows you the token once — copy it immediately. The token format starts with `pat` and is a long string of characters. If you lose it, you must revoke it and generate a new one. Store this token as AIRTABLE_API_KEY in your OpenClaw configuration.

terminal
1# Set your Airtable PAT in OpenClaw config
2clawhub config set AIRTABLE_API_KEY pat_XXXXXXXXXXXXXXXXXXXX
3
4# Verify it is set
5clawhub config get AIRTABLE_API_KEY

Pro tip: Select only the scopes you actually need when creating the PAT — `data.records:read` and optionally `data.records:write`. Avoid granting unnecessary permissions like org management or user administration.

Expected result: AIRTABLE_API_KEY is set in OpenClaw config. `clawhub config get AIRTABLE_API_KEY` returns a masked version of the token.

2

Find Your Airtable Base ID and Table ID

The Airtable REST API identifies bases and tables by their unique IDs rather than their display names. You need both the base ID and table ID (or table name) for API calls. **Base ID:** Open your Airtable base in the browser. The URL format is: `https://airtable.com/appXXXXXXXXXXXXXX/...`. The `appXXXXXXXXXXXXXX` portion (starting with `app`) is your base ID. **Table ID or name:** In the same URL, the next segment is the table ID (format: `tblXXXXXXXXXXXXXX`) or you can use the table name directly in API calls. The Airtable API accepts both the table ID and the table name (URL-encoded) in the endpoint path. Alternatively, navigate to airtable.com/developers/web/api/introduction and select your base from the dropdown — this shows the complete API documentation for your specific base including all table IDs and field names. Write down your base ID and the names of the tables you want to access — you will use these in the API endpoint paths in the next step.

terminal
1# Airtable URL structure:
2# https://airtable.com/{BASE_ID}/{TABLE_ID}/...
3# Example:
4# https://airtable.com/appABC123XYZ456/tblDEF789GHI012/...
5# ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
6# Base ID Table ID
7
8# Test the API connection and list tables in your base:
9curl -H "Authorization: Bearer pat_XXXXXXXXXXXXXXXXXXXX" \
10 "https://api.airtable.com/v0/meta/bases/appYOURBASEID/tables"

Pro tip: Bookmark the Airtable API documentation page for your specific base at airtable.com/developers/web/api/introduction — it shows auto-generated API docs with your actual field names and table IDs.

Expected result: You have your base ID (starting with 'app') and know the table names or table IDs (starting with 'tbl') for the tables you want to access.

3

Configure Airtable Integration in OpenClaw

OpenClaw's Direct API integration layer lets you configure reusable HTTP request patterns for services like Airtable. Create an integration config file that stores your base ID, default table, and API endpoint patterns. Open (or create) `~/.openclaw/config.yaml` and add the Airtable integration configuration under the `integrations` key. Set your base ID and any tables you want to access. The AIRTABLE_API_KEY is automatically read from your environment config — you do not repeat it in this file. After saving the config, run `clawhub reload` to apply it. Test the connection with the curl command in Step 2 or by asking OpenClaw to list records from a table.

~/.openclaw/config.yaml
1# ~/.openclaw/config.yaml
2integrations:
3 airtable:
4 base_id: "appYOURBASEIDHERE" # From your Airtable base URL
5 # Define tables you want to access
6 tables:
7 content_calendar: "Content Calendar" # Table name (or use tbl ID)
8 leads: "Leads"
9 tasks: "Task Queue"
10 # API settings
11 api_version: "v0" # Airtable API version
12 max_records: 100 # Max records per request (Airtable max: 100)
13 page_size: 100 # Records per page for paginated requests

Pro tip: Use table names (like 'Content Calendar') rather than table IDs in your config — names are human-readable and easier to maintain. Airtable's API accepts both formats.

Expected result: Config file saved with Airtable integration settings. `clawhub reload` completes without errors.

4

Read Records from Airtable

Test reading records from your Airtable table. The Airtable API returns records as JSON objects with an `id` field, a `createdTime` field, and a `fields` object containing your table's field values. For filtering records, Airtable uses its own formula syntax called filterByFormula — a string expression that evaluates against each record. Common patterns: filter by field value (`{Status}='Active'`), text contains (`SEARCH('keyword', {Notes})`), or date comparisons (`IS_AFTER({Due Date}, '2026-01-01')`). Pagination: Airtable returns up to 100 records per request. For tables with more records, the response includes an `offset` field — pass this as a query parameter to get the next page. The skill handles pagination automatically in most configurations, but for manual API calls you need to implement the pagination loop yourself.

terminal
1# Read all records from a table (max 100 per request)
2curl -H "Authorization: Bearer pat_XXXXXXXXXXXXXXXXXXXX" \
3 "https://api.airtable.com/v0/appYOURBASEID/Content%20Calendar"
4
5# Filter records by field value
6curl -H "Authorization: Bearer pat_XXXXXXXXXXXXXXXXXXXX" \
7 "https://api.airtable.com/v0/appYOURBASEID/Content%20Calendar?filterByFormula=%7BStatus%7D%3D'Ready%20to%20Publish'"
8
9# Sort records by a field
10curl -H "Authorization: Bearer pat_XXXXXXXXXXXXXXXXXXXX" \
11 "https://api.airtable.com/v0/appYOURBASEID/Content%20Calendar?sort%5B0%5D%5Bfield%5D=Due%20Date&sort%5B0%5D%5Bdirection%5D=asc"
12
13# Read a specific record by ID
14curl -H "Authorization: Bearer pat_XXXXXXXXXXXXXXXXXXXX" \
15 "https://api.airtable.com/v0/appYOURBASEID/Content%20Calendar/recXXXXXXXXXXXXXX"

Pro tip: URL-encode table names and field values in query parameters: spaces become %20, curly braces become %7B/%7D, and equals become %3D. Use a URL encoder tool or the `--data-urlencode` flag in curl to avoid encoding errors.

Expected result: The curl commands return JSON responses with record arrays. Each record has an `id`, `createdTime`, and `fields` object with your table's field values.

5

Create, Update, and Delete Airtable Records

The Airtable API uses standard HTTP methods for write operations: POST to create records, PATCH to update specific fields, PUT to replace all fields, and DELETE to remove records. For batch operations, Airtable allows creating, updating, or deleting up to 10 records per API call — pass an array of records in the request body. This is far more efficient than individual record operations when processing multiple items. Error handling is important for write operations. Airtable returns 422 errors for validation failures (wrong field type, required field missing, link to non-existent record), 429 for rate limiting (5 requests/second per base), and 403 for permission errors (PAT scope does not include write access). RapidDev recommends wrapping write operations in OpenClaw workflow steps that verify the response status before proceeding — catching errors early prevents partial updates that leave your Airtable data in an inconsistent state.

terminal
1# Create a new record
2curl -X POST \
3 -H "Authorization: Bearer pat_XXXXXXXXXXXXXXXXXXXX" \
4 -H "Content-Type: application/json" \
5 "https://api.airtable.com/v0/appYOURBASEID/Leads" \
6 -d '{
7 "fields": {
8 "Company Name": "Acme Corp",
9 "Contact Email": "contact@acme.com",
10 "Status": "New",
11 "Source": "OpenClaw"
12 }
13 }'
14
15# Update a record (PATCH updates only specified fields)
16curl -X PATCH \
17 -H "Authorization: Bearer pat_XXXXXXXXXXXXXXXXXXXX" \
18 -H "Content-Type: application/json" \
19 "https://api.airtable.com/v0/appYOURBASEID/Leads/recXXXXXXXXXXXXXX" \
20 -d '{"fields": {"Status": "Contacted", "Last Contacted": "2026-03-30"}}'

Pro tip: Airtable rate limits write operations to 5 requests per second per base. For bulk operations, use the batch endpoint (up to 10 records per call) and add a small delay between batches to avoid 429 rate limit errors.

Expected result: POST returns the created record with its new Airtable record ID. PATCH returns the updated record with the modified field values.

Common use cases

Read Airtable Records as Context

Load records from an Airtable table as structured data that OpenClaw can reference in subsequent actions — pulling a contact list for outreach, loading a content calendar for scheduling, or fetching product inventory for a report.

OpenClaw Prompt

Build an OpenClaw config that reads all records from my Airtable 'Content Calendar' table where the 'Status' field is 'Ready to Publish' and returns them as a list.

Copy this prompt to try it in OpenClaw

Create and Update Records from Workflows

Write data back to Airtable as the output of an OpenClaw workflow — creating a new lead record when a form is submitted, updating a project status when a task completes, or logging results from an automated process.

OpenClaw Prompt

Configure OpenClaw to create a new record in my Airtable 'Leads' table whenever triggered, with fields for Company Name, Contact Email, and Source.

Copy this prompt to try it in OpenClaw

Airtable as a Workflow Data Store

Use Airtable as a persistent data store for OpenClaw workflow state — tracking which items have been processed, storing configuration values that change frequently, or maintaining a history of completed automation runs.

OpenClaw Prompt

Set up an OpenClaw integration that reads 'pending' items from my Airtable 'Task Queue' table, processes each one, then updates the record status to 'completed' with a timestamp.

Copy this prompt to try it in OpenClaw

Troubleshooting

API returns '401 Unauthorized' or 'Authentication required'

Cause: AIRTABLE_API_KEY is not set in OpenClaw's config, or the token was revoked or expired. Airtable personal access tokens do not expire by default, but they can be revoked manually.

Solution: Run `clawhub config get AIRTABLE_API_KEY` to verify the key is set. If blank, re-run `clawhub config set AIRTABLE_API_KEY pat_your-token`. Verify the token is still active in Airtable Developer Hub (airtable.com/create/tokens) — revoked tokens cannot be recovered, generate a new one if needed.

typescript
1clawhub config set AIRTABLE_API_KEY pat_XXXXXXXXXXXXXXXXXXXX
2clawhub reload

API returns '403 Forbidden' on write operations

Cause: The personal access token was created with only `data.records:read` scope. Write operations require `data.records:write` scope.

Solution: Go to Airtable Developer Hub, find your token, and edit its scopes to add `data.records:write`. If the token does not allow scope editing after creation (some versions do not), revoke it and create a new one with the correct scopes.

API returns '422 Unprocessable Entity' when creating or updating records

Cause: The field names in your request body do not match Airtable's actual field names (case-sensitive), a required field is missing, or a field value has the wrong data type for the field configuration.

Solution: Check the exact field names in your Airtable table — they are case-sensitive. Visit the Airtable API documentation for your base (airtable.com/developers/web/api/introduction) to see the exact field names and accepted value formats. The 422 error response body usually includes a specific message about which field failed validation.

typescript
1# Check exact field names via the API
2curl -H "Authorization: Bearer pat_XXXXXXXXXXXXXXXXXXXX" \
3 "https://api.airtable.com/v0/meta/bases/appYOURBASEID/tables"

API returns '429 Too Many Requests'

Cause: Airtable's rate limit of 5 requests per second per base has been exceeded. This typically happens in loops or bulk processing without delays.

Solution: Add a 250ms delay between API requests in your OpenClaw workflow (one request every 200-250ms stays within the 5/second limit). For batch operations, use Airtable's batch endpoint which allows up to 10 records per request, reducing the total number of API calls needed.

typescript
1# Add delay between requests in shell scripts
2for record in $(cat records.txt); do
3 curl -X PATCH ... "$record"
4 sleep 0.25 # 250ms delay = 4 requests/second, within the 5/sec limit
5done

Best practices

  • Create a dedicated Airtable personal access token for OpenClaw with only the scopes it needs — read-only for read-only workflows, write access only for workflows that need to create or update records.
  • Use Airtable's batch API endpoints for bulk operations — up to 10 records per create/update/delete call — to stay within rate limits and reduce total API calls.
  • Store the Airtable base ID in your OpenClaw config file rather than hard-coding it in workflow scripts — this makes it easy to switch between development and production bases without code changes.
  • Use Airtable's filterByFormula parameter to retrieve only the records you need rather than fetching all records and filtering in OpenClaw — this reduces data transfer and API quota usage.
  • Handle pagination explicitly for tables with more than 100 records — check for the `offset` field in each response and use it to fetch subsequent pages until no offset is returned.
  • Validate field names and types against the Airtable API documentation for your specific base before deploying workflows that write data — field names are case-sensitive and type mismatches cause 422 errors.
  • For tables that change structure frequently, cache the table schema (field names and types) locally and refresh it periodically rather than fetching it on every API call.

Alternatives

Frequently asked questions

How do I set up Airtable integration in OpenClaw?

Generate a personal access token at airtable.com/create/tokens with `data.records:read` scope (add `data.records:write` if you need to create or update records). Set it in OpenClaw with `clawhub config set AIRTABLE_API_KEY pat_your-token`. Then configure your base ID in `~/.openclaw/config.yaml` under `integrations.airtable.base_id`. Test the connection with a curl command to the Airtable API.

What is the AIRTABLE_API_KEY for OpenClaw?

It is an Airtable personal access token (PAT) generated at airtable.com/create/tokens. It starts with `pat` followed by a long string. Personal access tokens replaced the older Airtable API key system in 2023. The token grants access to bases based on the scopes you selected during creation.

How do I find my Airtable base ID for OpenClaw?

Open your Airtable base in a browser. The URL format is `https://airtable.com/appXXXXXXXXXXXXXX/...`. The segment starting with `app` is your base ID. Alternatively, visit airtable.com/developers/web/api/introduction and select your base from the dropdown to see its ID in the generated documentation.

Why is my Airtable OpenClaw integration returning 403 Forbidden?

A 403 on write operations means your personal access token does not have `data.records:write` scope. Go to Airtable Developer Hub, edit your token's scopes to include write access, or create a new token with the correct scopes. A 403 on read operations means the token may not have access to that specific base — check the token's base access settings.

Does RapidDev offer help with Airtable OpenClaw integration?

Yes — RapidDev can assist with configuring complex Airtable workflows in OpenClaw, including multi-table operations, batch processing, and integrating Airtable as a data store for broader automation pipelines. Reach out to RapidDev if your use case involves advanced filtering, linked record handling, or multi-base architectures.

Can OpenClaw read linked records from Airtable?

Yes — linked record fields in Airtable return an array of record IDs in the API response. To get the actual field values from linked records, you make additional API calls to fetch those records by ID from the linked table. This is a common pattern that requires handling the join logic in your OpenClaw workflow configuration.

RapidDev

Talk to an Expert

Our team has built 600+ apps. Get personalized help with your project.

Book a free consultation

Need help with your project?

Our experts have built 600+ apps and can accelerate your development. Book a free consultation — no strings attached.

Book a free consultation

We put the rapid in RapidDev

Need a dedicated strategic tech and growth partner? Discover what RapidDev can do for your business! Book a call with our team to schedule a free, no-obligation consultation. We'll discuss your project and provide a custom quote at no cost.