# Airtable MCP MCP

> Airtable connects your AI agent directly to your low-code databases, giving it full control over records and workflows. Use this MCP to query schemas, list specific data points across any table, or orchestrate complex writes—all through natural conversation.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Tags:** airtable, low-code-api, database-automation, records-orchestration, schema-discovery, data-management, collaboration-tools, workspace-automation, mcp

## Description

You can connect your Airtable account to any AI client and take operational control of your bases without touching the UI. This allows your agent to act as a dedicated database engineer for all your low-code records and automated workflows. Need to know what data structure you're dealing with? You can first run `get_airtable_base_schema` to map out every table, field type, and view ID in real time. Once the schema is mapped, you can use tools like `list_airtable_records` or `get_airtable_record` to pull specific data sets for analysis. Beyond just reading, your agent handles the entire record lifecycle: it can `create_airtable_records` with structured JSON payloads, and then `update_airtable_record` if a status changes. Furthermore, you maintain team context by listing comments using `list_airtable_comments`, and clean up old data with `delete_airtable_record`. Vinkius makes connecting these operations seamless, giving your agent the power to orchestrate everything from one conversation.

## Tools

### create_airtable_records
Writes one or more new records into a designated table using structured field data.

### delete_airtable_record
Permanently removes an entire record from the base based on its ID.

### get_airtable_base_schema
Reads and returns the full blueprint of the Airtable base, detailing all tables and fields.

### get_airtable_record
Fetches all data points for a single record ID, giving you its complete metadata.

### list_airtable_comments
Retrieves the full history of comments and conversations tied to one specific record.

### list_airtable_records
Pulls a paginated list of records from a table, allowing you to see multiple entries quickly.

### update_airtable_record
Modifies specific fields or attachments on an existing record using its ID.

## Prompt Examples

**Prompt:** 
```
List all records in the 'Leads' table for base 'app123XYZ'.
```

**Response:** 
```
I've retrieved your leads. You currently have 15 records in table 'Leads', including 'Acme Corp' (Status: Qualified) and 'Global Tech'. Would you like the detailed high-fidelity metadata for any of these?
```

**Prompt:** 
```
Create a new record in table 'app123/tbl456' with fields Name='John' and Email='john@test.com'.
```

**Response:** 
```
Record created! I've successfully registered John (ID: rec1024) in specified table. The high-fidelity data is now live in your Airtable base. Shall I check for any existing comments on this lead?
```

**Prompt:** 
```
Show the schema for base ID 'app123XYZ'.
```

**Response:** 
```
Accessing base architecture... Base app123XYZ contains 3 tables: 'Leads', 'Interactions', and 'Revenue'. I've retrieved the high-fidelity field definitions and view IDs to help with automated data entry. Need a summary of the field types?
```

## Capabilities

### Read Database Structure
Retrieve the full schema of a base, mapping all tables and field types for programmatic understanding.

### List Records in a Table
Pull a paginated list of records from any specified table within your Airtable base.

### Retrieve Single Record Data
Fetch the complete, high-fidelity details for one specific record ID.

### Modify Records
Create new records or update existing data fields and attachments using a structured JSON payload.

### Manage Comments
Access all historical comments and conversation threads attached to a specific record for context review.

### Delete Records
Permanently remove specified records from any table in the base.

## Use Cases

### Lead Handoff After Discovery Call
The sales team completes a discovery call and needs the lead status updated. The agent first uses `get_airtable_record` to verify the current record details, then calls `update_airtable_record` to change the status from 'Initial' to 'Qualified,' logging the action in the system notes.

### Auditing Project Milestones
A project manager needs to see all discussion points around a specific deliverable. They instruct the agent to use `list_airtable_comments` on the record ID, retrieving the full context for review.

### Onboarding New Data Sources
A developer is integrating a new data source and needs to know its structure. They run `get_airtable_base_schema`, which immediately provides all table names, field types, and view IDs for integration planning.

### Archiving Completed Campaigns
The marketing team finishes a campaign and needs to remove the associated records. The agent first uses `list_airtable_records` to confirm all necessary entries are identified, then executes `delete_airtable_record` for bulk cleanup.

## Benefits

- You stop toggling between tabs. Instead of manually finding a record ID, use `get_airtable_record` to pull the exact data you need in one conversational query.
- Managing team context is simple. If you need to know what was discussed last week, `list_airtable_comments` pulls all history right into your agent's response.
- Schema discovery prevents mistakes. Before writing a single line of code, run `get_airtable_base_schema` so your agent knows the exact field types and structure.
- Data modification is safe. You can use `update_airtable_record` to change status fields or attach files without risking partial updates.
- Workflow automation gets easier. Combine listing records (`list_airtable_records`) with creating new ones (`create_airtable_records`) to build entire data pipelines.
- Clean up becomes a command. Need to archive old, unnecessary entries? Use `delete_airtable_record` to remove them instantly.

## How It Works

The bottom line is that you treat Airtable like a function library, calling specific methods instead of navigating through UI menus.

1. First, ensure your agent has access to the Airtable API via a Personal Access Token (PAT).
2. Next, prompt your AI client with a specific data request, like 'List all leads in the Sales table.'
3. The MCP executes the required sequence of calls (e.g., `list_airtable_records`) and returns the structured record data directly to your agent's context.

## Frequently Asked Questions

**How do I find out what tables are in my Airtable base with get_airtable_base_schema?**
You run `get_airtable_base_schema`. This function returns the full architectural blueprint of your entire base, listing all available tables and their field definitions for you to reference.

**Can I use list_airtable_records to get every single record?**
Yes, `list_airtable_records` retrieves records from a table. It handles pagination, which means it pulls groups of results so you can access large data sets.

**If I create new records, do they automatically get added to the right place?**
You must specify the target table when using `create_airtable_records`. The tool requires a JSON payload detailing which fields and values belong in the intended location.

**How do I check team discussions on a specific record with list_airtable_comments?**
`list_airtable_comments` takes a single record ID as input. It then returns all associated comments and conversation threads attached to that exact piece of data.

**If I use the `delete_airtable_record` tool, is there a way to prevent accidental data loss?**
No. The deletion action is immediate and permanent across your base. You must provide the exact Record ID; there's no soft delete feature through this MCP.

**How do I efficiently pull the details for one specific record using `get_airtable_record`?**
You just need to pass the unique Record ID, and your agent fetches all associated data fields immediately. This is much faster than listing records and filtering later.

**Can I use `update_airtable_record` to change only a single field without affecting other data?**
Yes. You specify the Record ID and list only the fields you want changed. This prevents your AI client from accidentally overwriting existing, correct data.

**When I run `create_airtable_records`, does the tool validate my input against the base schema?**
It does. The MCP uses the current base structure to validate every field you provide. If a field is missing or formatted incorrectly, the operation fails before writing data.