Migrating from Airtable to DenchClaw

Airtable is expensive. The free tier limits rows and history, and as soon as your team grows, you're looking at $20+/user/month for features that should be basic. DenchClaw gives you a local-first CRM with AI queries, a DuckDB backend, and zero licensing fees — open source, MIT licensed.

Migration takes an afternoon if you're organized. Here's the exact process.

Why Migrate from Airtable#

Before the technical steps, here's what you're trading:

What you gain with DenchClaw:

• No row limits, no user seat costs, runs entirely on your machine
• Natural language queries — ask "who did I talk to last week?" in plain English via Telegram or Discord
• DuckDB backend — run any SQL query, fast, even on millions of rows
• Open source (MIT) — you own your data completely, no vendor lock-in
• Browser agent that's already logged into your accounts (no API keys for existing sessions)

What you lose:

• Airtable's visual table/gallery/kanban in one screen (DenchClaw has kanban and table views but they're separate)
• Real-time collaboration (DenchClaw is single-user or small-team local by default)
• Airtable's automation builder (replaced by webhooks, CLI scripts, and skills)
• Airtable's integrations marketplace (replaced by open-source skills)

If you're a solo founder or small team doing sales and contact management, DenchClaw wins on cost and AI features. If you're a 50-person operations team with complex workflows, evaluate carefully.

Step 1: Export Your Airtable Bases to CSV#

Airtable's CSV export is reliable but slightly hidden.

1. Open your Airtable base
2. Select the table you want to export
3. Click the Grid view name in the top-left, then click the ... next to it
4. Select Download CSV
5. Repeat for each table/view you want to migrate

For large bases with multiple tables, export each table separately. You'll get one CSV per table.

Tips for clean exports:

• Export from your most important view (not a filtered view you don't need)
• Make sure all fields are visible before exporting — hidden fields won't appear in the CSV
• If you have linked record fields, export the linked table too

Step 2: Map Airtable Field Types to DenchClaw#

Airtable has a rich set of field types. Most map cleanly to DenchClaw's field types. Here's the full mapping:

Focus on text, select, date, number, email, phone, url fields first — those migrate perfectly. Computed fields (rollup, lookup, formula) you'll re-create in DuckDB after the import.

Step 3: Clean Your CSV Files#

Before importing, clean up your exports:

# Preview the CSV structure
head -5 contacts.csv
 
# Check for encoding issues (Airtable usually exports UTF-8 but verify)
file contacts.csv
 
# Count rows
wc -l contacts.csv

Common issues to fix:

• Dates: Airtable exports dates as 2024-03-15 which DuckDB handles fine. But if you have custom date fields, check the format.
• Currency: Strip $ and , characters from currency fields. In bash: sed 's/\$//g; s/,//g'
• Linked records: These export as plain text (the linked record's name). You'll handle relations separately.
• Attachments: These export as URLs pointing to Airtable's CDN. Download them before migrating (see below).

Step 4: Import CSV into DuckDB#

Basic import#

npx denchclaw import csv \
  --file contacts.csv \
  --object people \
  --dedupe email

Import with field mapping#

If your CSV headers don't match DenchClaw's field names:

npx denchclaw import csv \
  --file contacts.csv \
  --object people \
  --field-map \
    "Full Name:name" \
    "Email Address:email" \
    "Company:company_name" \
    "Phone:phone" \
    "Status:status" \
    "Deal Stage:pipeline_stage" \
  --dedupe email

Bulk import via DuckDB directly#

For large files (10,000+ rows), import directly using DuckDB's COPY command for better performance:

-- First, create a staging table
CREATE TABLE contacts_import AS 
SELECT * FROM read_csv_auto('/path/to/contacts.csv', header=true);
 
-- Preview the data
SELECT * FROM contacts_import LIMIT 5;
 
-- Check for issues
SELECT COUNT(*), COUNT(DISTINCT "Email Address") FROM contacts_import;
 
-- Then run the DenchClaw import CLI which handles the EAV transformation

Or let DenchClaw handle it:

npx denchclaw import csv --file contacts.csv --object people --batch-size 500

Step 5: Recreate Views in DenchClaw#

Airtable views (Grid, Gallery, Kanban, Calendar) map to DenchClaw's views:

Create a kanban view#

npx denchclaw view create \
  --object people \
  --name "Pipeline" \
  --type kanban \
  --group-by status

Create a filtered table view#

npx denchclaw view create \
  --object people \
  --name "Active Leads" \
  --type table \
  --filter "status IN ('Lead', 'Qualified')" \
  --sort "created_at DESC"

Step 6: Handle Linked Records and Relations#

Airtable linked records become relation fields in DenchClaw. Here's how to recreate them.

Create a relation field#

# Add a "company" relation to people, pointing to the companies object
npx denchclaw field create \
  --object people \
  --name "Company" \
  --type relation \
  --target companies

Link existing entries via SQL#

After importing both tables, use DuckDB to link them:

-- Find the company entry ID for each person
UPDATE entry_fields ef
SET value = (
  SELECT c.entry_id 
  FROM entries c
  JOIN entry_fields cf ON c.id = cf.entry_id 
  WHERE cf.field_name = 'name' 
    AND cf.value = (
      SELECT value FROM entry_fields 
      WHERE entry_id = ef.entry_id 
        AND field_name = 'company_name'
    )
  LIMIT 1
)
WHERE ef.field_name = 'company_relation'
  AND ef.value IS NULL;

This is the one truly manual step of the migration. If your Airtable has complex linked-record networks, budget 2-3 hours to work through them.

Step 7: Preserve Attachments#

Airtable attachment URLs expire after a short time. Download them before migrating.

import pandas as pd
import requests
import os
from urllib.parse import urlparse
 
df = pd.read_csv('contacts.csv')
os.makedirs('attachments', exist_ok=True)
 
for idx, row in df.iterrows():
    if pd.notna(row.get('Attachments')):
        # Airtable exports attachments as a JSON-ish string or comma-separated URLs
        # Parse appropriately for your export format
        urls = str(row['Attachments']).split(',')
        for url in urls:
            url = url.strip()
            filename = os.path.basename(urlparse(url).path)
            response = requests.get(url)
            with open(f'attachments/{filename}', 'wb') as f:
                f.write(response.content)
            print(f"Downloaded: {filename}")

After downloading, update the attachment field in DenchClaw with local file paths.

Migration Timeline#

Here's a realistic timeline for different base sizes:

Plan the migration in this order:

1. Export and clean CSVs (1 hour)
2. Import main objects (people, companies, deals) (1-2 hours)
3. Verify data integrity with DuckDB queries (30 min)
4. Re-create views and filters (1 hour)
5. Set up linked records (1-2 hours for complex setups)
6. Test with real workflows (30 min)

FAQ#

Can I import Airtable automation workflows? Not directly. DenchClaw uses webhooks and skills instead of Airtable's automation builder. Document your automations, then recreate them as DenchClaw webhooks or shell scripts.

What happens to my Airtable formula fields? Formula fields don't import — the calculated values in the CSV export are snapshots, not live formulas. In DenchClaw, re-create formulas as DuckDB views or computed fields.

Can I run DenchClaw and Airtable in parallel during migration? Yes, and recommended. Migrate a copy of your data first, validate it, then cut over. Keep Airtable running until you're confident in the migration.

How do I handle Airtable's multiple-select fields? Multi-select fields export as comma-separated strings in CSV. DenchClaw's multi_select field type stores these the same way. The import should handle them automatically.

What if I have custom apps or extensions built on Airtable? Airtable extensions that use the Airtable API need to be rebuilt using DenchClaw's API or the Bridge API (for Dench Apps). Plan additional time if you have custom integrations.

Ready to try DenchClaw? Install in one command: npx denchclaw. Full setup guide →