Airtable is where teams track everything from sales pipelines to content calendars to product backlogs. The problem is that updating it takes constant tab-switching: open the base, find the right table, locate the record, edit the field, repeat. OpenClaw eliminates that loop. By writing a custom skill that talks to Airtable’s REST API, you turn your AI agent into a conversational database interface that reads, creates, and updates records from a Telegram or WhatsApp message.
This guide covers the full setup: generating an Airtable Personal Access Token, writing the OpenClaw skill file with CRUD operations, and testing it with real queries. If OpenClaw is already running on your machine, expect about 20 minutes of work.
What You Get After This Setup
Once the skill is live, your OpenClaw agent can interact with any Airtable base you grant access to. Here is what that looks like in practice:
- Query records by any field — “Show me all blog posts in the Content Calendar where Status is Draft”
- Create new records from chat — “Add a new lead: Jane Smith, jane@acme.com, source is LinkedIn”
- Update existing records — “Move the Acme onboarding task to Done”
- List and filter across tables — “What tasks are assigned to me that are due this week?”
- Run scheduled reports — “Every Monday at 9 AM, send me a summary of overdue items”
The agent sends curl requests to Airtable’s REST API using a Personal Access Token. No middleware, no Zapier, no paid connectors. Your data flows directly between your machine and Airtable’s servers.
Before You Start
Three things need to be in place:
-
OpenClaw installed and running. If you have not set it up yet, follow our OpenClaw setup guide. That covers installation, workspace files, memory configuration, and Telegram setup.
-
An Airtable account with at least one base. The free tier works fine for API access. You do not need a paid plan to use the REST API or create Personal Access Tokens.
-
Your Airtable Base ID. Open any base in Airtable and look at the URL:
airtable.com/appXXXXXXXXXXXXXX/.... The string starting withappis your Base ID. Copy it somewhere. You will need it for the skill file.
Step 1: Create an Airtable Personal Access Token
Airtable replaced its legacy API keys with Personal Access Tokens (PATs) in 2024. PATs are scoped, meaning you control exactly which bases and operations the token can access.
- Go to airtable.com/create/tokens (or navigate to your account settings, then Developer Hub, then Personal Access Tokens)
- Click Create new token
- Name it something descriptive:
OpenClaw Integration - Under Scopes, add these permissions:
| Scope | What It Enables |
|---|---|
data.records:read | Read records from tables |
data.records:write | Create, update, and delete records |
schema.bases:read | List bases and table structures |
Start with these three scopes. You can add more later (comments, webhooks, user management) as your automations expand.
-
Under Access, select the specific base(s) you want OpenClaw to access. We recommend granting access to individual bases rather than “all bases” to follow the principle of least privilege.
-
Click Create token and copy it immediately. Airtable shows the token once. If you lose it, you will need to delete the token and create a new one.
Store the Token Safely
Never paste the token directly into your skill file. Store it in a .env file:
# ~/.env or ~/openclaw/.env
AIRTABLE_PAT=patXXXXXXXXXXXXXXXXX.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
AIRTABLE_BASE_ID=appXXXXXXXXXXXXXX
OpenClaw reads environment variables at runtime. This keeps the secret out of any file your agent might log or share.
Step 2: Write the OpenClaw Airtable Skill
OpenClaw skills are Markdown files that teach your agent how to call external APIs. The skill file lives in your workspace’s skills/ directory and contains authentication details, endpoint templates, and behavioral rules.
Create the Skill Directory
mkdir -p ~/.openclaw/workspace/skills/airtable
Write the SKILL.md File
Create ~/.openclaw/workspace/skills/airtable/SKILL.md with this content:
---
name: airtable
description: Read and write Airtable base data. Manage records across any table using the Airtable REST API.
tools:
- shell
---
# Airtable Skill
## Authentication
Use the environment variable `AIRTABLE_PAT` for all API requests.
The base ID is stored in `AIRTABLE_BASE_ID`.
All requests go to `https://api.airtable.com/v0/$AIRTABLE_BASE_ID/` with the header:
Authorization: Bearer $AIRTABLE_PAT
## Available Operations
### List Records from a Table
Fetch records with optional filtering:
curl -s -H "Authorization: Bearer $AIRTABLE_PAT" \
"https://api.airtable.com/v0/$AIRTABLE_BASE_ID/TABLE_NAME?maxRecords=50" \
| jq '.records[] | {id: .id, fields: .fields}'
To filter records, use the filterByFormula parameter:
curl -s -H "Authorization: Bearer $AIRTABLE_PAT" \
--data-urlencode "filterByFormula={Status}='Active'" \
"https://api.airtable.com/v0/$AIRTABLE_BASE_ID/TABLE_NAME" \
| jq '.records[] | {id: .id, fields: .fields}'
### Get a Single Record
curl -s -H "Authorization: Bearer $AIRTABLE_PAT" \
"https://api.airtable.com/v0/$AIRTABLE_BASE_ID/TABLE_NAME/RECORD_ID" \
| jq '.fields'
### Create a New Record
curl -s -H "Authorization: Bearer $AIRTABLE_PAT" \
-H "Content-Type: application/json" \
-X POST "https://api.airtable.com/v0/$AIRTABLE_BASE_ID/TABLE_NAME" \
-d '{
"records": [{
"fields": {
"Name": "VALUE",
"Email": "VALUE",
"Status": "VALUE"
}
}]
}' | jq '.records[0] | {id: .id, fields: .fields}'
### Update an Existing Record
curl -s -H "Authorization: Bearer $AIRTABLE_PAT" \
-H "Content-Type: application/json" \
-X PATCH "https://api.airtable.com/v0/$AIRTABLE_BASE_ID/TABLE_NAME" \
-d '{
"records": [{
"id": "RECORD_ID",
"fields": {
"Status": "NEW_VALUE"
}
}]
}' | jq '.records[0].fields'
### Delete a Record
curl -s -H "Authorization: Bearer $AIRTABLE_PAT" \
-X DELETE "https://api.airtable.com/v0/$AIRTABLE_BASE_ID/TABLE_NAME?records[]=RECORD_ID" \
| jq '.records[0].deleted'
## Pagination
Airtable returns a maximum of 100 records per request. If there are more results, the response includes an "offset" field. To get the next page:
curl -s -H "Authorization: Bearer $AIRTABLE_PAT" \
"https://api.airtable.com/v0/$AIRTABLE_BASE_ID/TABLE_NAME?offset=OFFSET_VALUE" \
| jq '{records: [.records[] | .fields], offset: .offset}'
Always check for an offset in the response. If present, fetch the next page. Continue until no offset is returned.
## Rules
- Always confirm before creating, updating, or deleting records. Show the user what will change and wait for approval.
- When listing records, default to 50 unless the user asks for more.
- Use filterByFormula for searches instead of fetching all records and filtering locally.
- Table names with spaces must be URL-encoded (replace spaces with %20).
- Respect rate limits: Airtable allows 5 requests per second per base.
- Never log the access token in responses or memory files.
- When a request fails, show the error message from Airtable's response body.
Understanding the Skill Structure
The frontmatter tells OpenClaw when to activate this skill and which tools it needs. The shell tool gives your agent access to curl and jq.
The operations section provides templated API calls the agent adapts to your requests. When you ask “Show me all tasks due this week,” the agent reads the list endpoint template, substitutes the correct table name and filter formula, runs the curl command, and parses the JSON response into a readable summary.
The rules section is your safety net. The confirmation requirement for write operations prevents the agent from silently creating duplicate records or deleting the wrong entry. Agents can misinterpret ambiguous instructions, so a confirmation step is worth the minor friction.
Step 3: Test the Connection
Restart OpenClaw to load the new skill:
openclaw gateway restart
Open your chat with your OpenClaw agent and run through these tests:
Read test:
“List the first 5 records from my Projects table”
The agent should run a list API call and return the field values for each record.
Search test:
“Find all records in Contacts where Company is Acme Corp”
The agent should use filterByFormula and return matching records.
Write test:
“Add a new record to Tasks: Name is ‘Review Q2 report’, Status is ‘To Do’, Assignee is ‘Me’”
The agent should show you the proposed record and ask for confirmation before creating it.
If something fails, check these common issues:
| Symptom | Likely Cause | Fix |
|---|---|---|
| 401 Unauthorized | Token is wrong or expired | Create a new PAT in Airtable’s Developer Hub |
| 403 Forbidden | Token lacks the required scope | Add the missing scope to your PAT |
| 404 Not Found | Wrong Base ID or table name | Verify the Base ID from your Airtable URL and check table name spelling |
| Empty results | Filter formula syntax error | Test the formula in Airtable’s filter UI first |
| 422 Unprocessable | Invalid field name or value | Check field names match your table schema exactly (case-sensitive) |
What to Automate First
After the connection works, start small. The fastest way to break trust in an AI agent is to give it full write access to a production database on day one.
Week 1: Read-Only Lookups
Use the agent for quick database queries during your workday:
- “How many open tasks are there in Sprint 14?”
- “What is the status of the Acme Corp deal?”
- “Show me all blog posts published in March”
This builds your muscle memory for talking to Airtable through chat and lets you verify the agent’s responses against the actual Airtable UI.
Week 2: Create and Update Records
Once lookups feel reliable, start writing data:
- “Add a new contact: Sarah Johnson, sarah@globex.com, Lead Source is Webinar”
- “Change the status of ‘Homepage Redesign’ to In Progress”
- “Log a note on the Acme Corp record: Spoke with Jim, he wants pricing by Thursday”
Week 3: Scheduled Automations
Use OpenClaw’s heartbeat scheduling or cron jobs to automate recurring checks:
## Weekly Content Review (runs Monday 9:00 AM)
Check the Content Calendar table in Airtable.
Find all records where Status is "Draft" and Due Date is within the next 7 days.
Send me a summary with the article title, assignee, and due date.
## Stale Lead Alert (runs daily at 8:00 AM)
Check the CRM Leads table for records where Last Contact is more than 14 days ago
and Status is not "Closed Won" or "Closed Lost".
Send me a list with the lead name, company, and days since last contact.
This read-then-write-then-automate progression gives you time to catch mistakes before they compound.
Security Considerations
Your Airtable PAT has direct access to your data. Treat it like a database password.
Scope narrowly. Only enable the scopes you need right now. If you are not using webhook or comment features, do not add those scopes. You can expand permissions later without disrupting existing functionality.
Restrict base access. When creating the PAT, select specific bases rather than granting access to all current and future bases. If the token is ever compromised, the blast radius stays small.
Store tokens in .env files. Never put the PAT in agents.md, soul.md, or any workspace file your agent reads into context. Environment variables loaded at runtime keep secrets out of the agent’s conversation history.
Require confirmation for writes. The Rules section in the skill file should mandate confirmation before any create, update, or delete operation. This is your primary guardrail against misunderstood instructions.
For a deeper overview of OpenClaw security practices, see Step 9 in our OpenClaw setup guide.
Frequently Asked Questions
Do I need a paid Airtable plan to connect OpenClaw?
Airtable’s free plan includes full REST API access and the ability to create Personal Access Tokens. The free tier limits you to 1,000 records per base and 1,000 API calls per month per base, which is plenty for personal or small-team use. Paid plans (Team and Business) raise these limits and unlock features like record revision history and Gantt views, but the core API integration works without a paid plan.
How long does this setup take?
About 20 minutes if OpenClaw is already running. Creating the PAT takes 3 minutes. Writing and pasting the SKILL.md file takes 5 minutes. Testing takes another 10. If you need to install OpenClaw first, add 30-45 minutes for the initial setup.
Can OpenClaw automatically update Airtable records on a schedule?
OpenClaw supports this through heartbeat instructions and cron jobs. You define a rule like “every morning, find overdue tasks and send me a list,” and the agent runs it on schedule. We recommend starting with read-only scheduled tasks before allowing automated writes. An agent that silently moves records to the wrong status at 3 AM is hard to debug.
What happens if I hit Airtable’s API rate limit?
Airtable enforces 5 requests per second per base. In normal conversational use, you will never reach this. If you set up aggressive automated scans, you could. The API returns a 429 status code. Add a note to your skill’s Rules section: “If you receive a 429 response, wait 2 seconds and retry once.” Most LLMs handle this gracefully when instructed.
Can I connect multiple Airtable bases to the same OpenClaw agent?
Yes. You have two options: store multiple base IDs as separate environment variables (AIRTABLE_BASE_ID_CRM, AIRTABLE_BASE_ID_CONTENT) and reference them in your skill, or create a single PAT with access to all relevant bases and let the agent select the right base ID based on your request. The first approach is cleaner for security. The second is simpler to maintain.
Is it safe to give an AI agent access to my Airtable data?
As safe as you configure it. Use least-privilege scoping (only the scopes and bases you need), store tokens in .env files, and require confirmation for destructive operations. OpenClaw runs on your machine, so data does not pass through third-party middleware. The biggest risk is the agent misinterpreting an instruction and updating the wrong record, which is why the confirmation rule in the skill file matters.
Key Takeaways
- Connect Airtable to OpenClaw by creating a Personal Access Token and writing a SKILL.md file with curl-based API call templates
- Start with three scopes:
data.records:read,data.records:write, andschema.bases:read - Store your token in a
.envfile, never inside workspace files the agent can read - Test with read-only queries first, then add write operations, then automate with scheduled tasks
- Airtable’s free plan supports the full API integration with no paid connectors or middleware required
SFAI Labs
