Airtable has no "download all attachments" button. If a base holds a few hundred contracts, photos or invoices and you need them on disk, you have three realistic options: click through the interface, write a script against the API, or use a tool that does the scripting for you. This article covers all three, including a complete Node.js script that I ran before publishing.

One scope note up front: Airtable attachments live in fields of a table, not in the base as a whole. For a whole base, run the script (or the browser tool) once per table.

Way 1: the Airtable interface, and where it stops

In the interface you can:

• Open a record (the expand icon), hover over an attachment and click the download icon. That is one file per click.
• Export a view as CSV from the view menu (Download CSV).

The CSV export is where people expect more than they get. An attachment cell in the CSV contains the file name and a URL, not the file. Those URLs are the problem. Airtable's attachment URL behavior article says download URLs expire for security reasons, and that Airtable will keep them active for at least 2 hours after you receive them. The Web API field model says the same for the API: URLs expire 2 hours after the API returns them, and if you want to keep the files you should download them instead of storing the URL.

So a CSV full of attachment URLs is not a backup of your files. An hour later the links may work; a day later they will not. There is a longer write-up of this in why Airtable attachment links in a CSV export stop working.

Airtable's own attachment fields article also confirms there is no built-in bulk download, and includes a Scripting extension example for it, which it describes as simplified and likely to have limitations.

The manual route is fine for ten files. For anything bigger you need the API.

Way 2: a Node.js script

Everything below works with a personal access token. Create one at airtable.com/create/tokens with the scope data.records:read and add the base you want to export. The script needs nothing else. A read-only token is all it takes; it never writes to your base.

You need:

• Node 18 or newer (for the built-in fetch). No npm packages.
• Your base ID (starts with app, visible in the URL of the base).
• The table name or ID.

What the script does:

• Lists records page by page, following Airtable's offset until there is none. 100 records per page.
• Optionally reads only one view, so the view's filters apply.
• Looks at every field of every record and treats any array of objects with a url and a filename as attachments. You do not have to name the fields, though you can restrict it with FIELDS.
• Saves each file into attachments/<record id>/. The file name is the attachment ID plus the original name, which keeps two files called scan.pdf in one record apart.
• Cleans file names: characters that are illegal on Windows or act as path separators become _, leading and trailing dots and spaces are removed, Windows reserved names like CON get a prefix, and very long names are cut to 120 characters while keeping the extension.
• Skips files that already exist, so you can re-run it after an interruption. Files are written to a .part file first and renamed when complete, so a half-downloaded file is never mistaken for a finished one.
• Spaces API calls 220 ms apart to stay under Airtable's limit of 5 requests per second per base, and on HTTP 429 waits 30 seconds, which is what Airtable asks for. It also retries 5xx errors a few times.
• Downloads the files of each page before fetching the next page. That matters because the URLs in a page are only good for about 2 hours. Collecting all URLs first and downloading later would break on a big table.

Save this as download-attachments.mjs:

// download-attachments.mjs
// Download every attachment in an Airtable table (or one view) into one folder per record.
// Node 18+, no dependencies.
//
//   AIRTABLE_TOKEN=pat... BASE_ID=app... TABLE="My table" node download-attachments.mjs
//
// Optional: VIEW="Grid view"  OUT_DIR=./attachments  FIELDS="Photos,Contracts"

import { createWriteStream } from 'node:fs';
import { mkdir, stat, rename, rm } from 'node:fs/promises';
import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import path from 'node:path';

const {
  AIRTABLE_TOKEN,
  BASE_ID,
  TABLE,
  VIEW,
  OUT_DIR = './attachments',
  FIELDS, // comma-separated field names; default: every attachment field found
  API_ROOT = 'https://api.airtable.com', // only change this for testing
  PAGE_SIZE = '100',
} = process.env;

if (!AIRTABLE_TOKEN || !BASE_ID || !TABLE) {
  console.error('Set AIRTABLE_TOKEN, BASE_ID and TABLE (and optionally VIEW, OUT_DIR, FIELDS).');
  process.exit(1);
}

const only = FIELDS ? new Set(FIELDS.split(',').map((s) => s.trim())) : null;
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

// Airtable allows 5 requests per second per base. Space API calls 220 ms apart.
let lastCall = 0;
async function throttle() {
  const wait = lastCall + 220 - Date.now();
  if (wait > 0) await sleep(wait);
  lastCall = Date.now();
}

// fetch with retry on 429 (Airtable asks you to wait 30 s) and 5xx.
async function request(url, options = {}, { api = false } = {}) {
  for (let attempt = 1; ; attempt++) {
    if (api) await throttle();
    const res = await fetch(url, options);
    if (res.ok) return res;
    const retryable = res.status === 429 || res.status >= 500;
    if (!retryable || attempt >= 5) {
      const body = await res.text().catch(() => '');
      throw new Error(`HTTP ${res.status} for ${url.split('?')[0]} ${body.slice(0, 200)}`);
    }
    const delay = res.status === 429 ? 30_000 : 1000 * 2 ** attempt;
    console.warn(`HTTP ${res.status}, retrying in ${delay / 1000}s`);
    await res.body?.cancel();
    await sleep(delay);
  }
}

const RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i;

function sanitise(name, fallback = 'file') {
  let s = String(name ?? '')
    .normalize('NFC')
    .replace(/[\u0000-\u001f\u007f<>:"/\\|?*]/g, '_') // illegal on Windows, or a path separator
    .replace(/^[.\s]+|[.\s]+$/g, ''); // no leading/trailing dots or spaces
  if (!s) s = fallback;
  if (RESERVED.test(s)) s = `_${s}`;
  if (s.length > 120) {
    const ext = path.extname(s).slice(0, 12);
    s = s.slice(0, 120 - ext.length) + ext;
  }
  return s;
}

// An attachment is an object with id, url and filename. This also matches
// lookup fields that pull in attachments from a linked table.
const isAttachment = (x) =>
  x && typeof x === 'object' && typeof x.url === 'string' && typeof x.filename === 'string';

async function exists(file) {
  try {
    return (await stat(file)).size > 0;
  } catch {
    return false;
  }
}

async function downloadOne(att, dir) {
  const file = path.join(dir, `${sanitise(att.id)}_${sanitise(att.filename)}`);
  if (await exists(file)) return 'skipped';
  await mkdir(dir, { recursive: true });
  const res = await request(att.url);
  const tmp = `${file}.part`;
  try {
    await pipeline(Readable.fromWeb(res.body), createWriteStream(tmp));
    await rename(tmp, file);
  } catch (err) {
    await rm(tmp, { force: true });
    throw err;
  }
  return 'downloaded';
}

async function main() {
  const base = `${API_ROOT}/v0/${BASE_ID}/${encodeURIComponent(TABLE)}`;
  const headers = { Authorization: `Bearer ${AIRTABLE_TOKEN}` };
  const stats = { pages: 0, records: 0, withFiles: 0, downloaded: 0, skipped: 0, failed: 0 };
  let offset;

  do {
    const qs = new URLSearchParams({ pageSize: PAGE_SIZE });
    if (VIEW) qs.set('view', VIEW);
    if (offset) qs.set('offset', offset);
    const res = await request(`${base}?${qs}`, { headers }, { api: true });
    const page = await res.json();
    stats.pages++;

    // Download this page right away: the URLs in it expire about two hours after Airtable returns them.
    for (const record of page.records) {
      stats.records++;
      let hasFiles = false;
      for (const [fieldName, value] of Object.entries(record.fields)) {
        if (only && !only.has(fieldName)) continue;
        if (!Array.isArray(value) || !value.length || !value.every(isAttachment)) continue;
        hasFiles = true;
        const dir = path.join(OUT_DIR, record.id);
        for (const att of value) {
          try {
            const result = await downloadOne(att, dir);
            stats[result]++;
          } catch (err) {
            stats.failed++;
            console.error(`FAILED ${record.id} / ${fieldName} / ${att.filename}: ${err.message}`);
          }
        }
      }
      if (hasFiles) stats.withFiles++;
    }

    offset = page.offset; // absent on the last page
    console.log(`page ${stats.pages}: ${stats.records} records so far, ${stats.downloaded} files downloaded`);
  } while (offset);

  console.log('done', JSON.stringify(stats));
  if (stats.failed) process.exitCode = 2;
}

main().catch((err) => {
  console.error(err.message);
  process.exit(1);
});

Run it:

export AIRTABLE_TOKEN=patXXXXXXXXXXXXXX.xxxxxxxx   # your token
export BASE_ID=appXXXXXXXXXXXXXX
export TABLE="Clients"                              # table name or tbl... ID
# optional: export VIEW="Grid view"  OUT_DIR=./attachments  FIELDS="Photos,Contracts"
node download-attachments.mjs

It prints one line per page and a summary with the counts of downloaded, skipped and failed files. The exit code is 2 if any file failed, so you can use it in a cron job or CI step.

What I actually ran

I ran this exact file with Node on a small test base. Two things were checked, and only the first against Airtable itself:

• Against the real Airtable API: a table of 8 records. With the default page size it read 1 page. With PAGE_SIZE=2 it followed the offset through 4 pages and counted the same 8 records. That test table has no attachment fields, so no file was downloaded from Airtable's servers.
• Download path, against a local mock server that imitates the API: 5 records in 3 pages, one record with an empty attachment field, one linked-records field that must be ignored, file names such as a/b:c?.pdf, CON.txt and a 200-character name, one temporary HTTP 500 and one permanent HTTP 404. Result: 11 files downloaded into per-record folders, the 500 retried successfully, the 404 reported as failed with exit code 2, and a second run skipped all 11 existing files.

That is the honest limit of the test. The code that talks to airtableusercontent.com is a plain fetch of a URL, so I expect it to behave the same on a real attachment, but I have not watched it do so on one.

A quick curl and jq version

If you only want the list of URLs, for example to feed wget, this does it for the first 100 records:

curl -s -H "Authorization: Bearer $AIRTABLE_TOKEN" \
  "https://api.airtable.com/v0/$BASE_ID/$TABLE?pageSize=100" |
jq -r '.records[] | .id as $rec | .fields[]
  | select(type == "array") | .[]
  | select(type == "object" and has("url"))
  | [$rec, .filename, .url] | @tsv'

Each line is the record ID, file name and URL, separated by tabs. For more than 100 records you have to pass the offset from each response into the next request, which is what the script handles for you. Remember the same expiry applies: download the files soon after listing them. I ran this jq filter against the same mock data as above (12 attachment rows from 4 records) and the real table (which has no attachments, so it returns nothing there).

Way 3: the free browser tool

If you would rather not run code, ViewCourier has a free tool: Download all Airtable attachments. It does what the script does, with a form.

1. Paste a personal access token with the scopes data.records:read and schema.bases:read, and add the base to the token.
2. Choose the base, the table and, optionally, a view.
3. Tick the attachment fields you want.
4. Pick a layout: one folder per record (named after the record's primary field), a flat list with the record name in front of each file name, or a flat list with the original file names.
5. Click Scan. The tool reads the records through the API and shows how many files there are, their total size and the largest file.
6. Click Download ZIP.

Some details that matter:

• The page runs in your browser. The token is sent only to api.airtable.com, and the files go straight from Airtable's file servers to your computer. Nothing goes through ViewCourier's servers and nothing is stored there.
• The ZIP is built in the browser's memory. Large jobs are split into parts of up to 500 MB (and 10,000 files), each of which downloads as soon as it is ready. The tool's page lists a limit of 100,000 files and 20 GB per run.
• Each ZIP contains attachments-manifest.csv, which lists record ID, record name, field, path inside the ZIP, original file name, size and status for every file. That is handy for checking that nothing is missing, or for matching files to records later.
• File names Windows or macOS cannot handle are cleaned, and duplicate names get (2), (3) and so on.
• It fetches fresh links when you scan, so scan and download in one sitting.

For a whole base, repeat the process per table. Delete the token afterwards if you do not need it any more; you can create a new one in a minute.

Which one to use

• A handful of files: the interface.
• Recurring downloads, a server, a cron job, or files going to your own storage: the script. You control naming, destination and scheduling.
• A one-off bulk download without code, with a manifest: the browser tool.

Whichever you pick, do it soon after the links are generated, and keep the files themselves. A list of URLs will not outlive the afternoon.

One more thing

The files are one half of a backup; the records are the other. ViewCourier can email an Airtable view as a CSV, XLSX or PDF on a schedule, and there is a Free plan. The rest of the free tools are listed on the tools page.

Airtable has no "Export base to JSON" button. The UI gives you CSV per view, and that's it. If you want JSON, for a backup, a migration, a static site, or just to feed another script, you have to go through the API or use a tool that does that for you.

Here are three ways to do it, from most flexible to least effort. I tested the script and the shell loop below against a real base before writing this.

Before you start: get a token

All three methods need a personal access token (PAT).

1. Open airtable.com/create/tokens and click Create token.
2. Add the scopes data.records:read and schema.bases:read.
3. Under Access, pick the base (or bases) you want to export.
4. Copy the token. It starts with pat.

You also need the base ID (starts with app). It's in the URL when you open the base: airtable.com/appXXXXXXXXXXXXXX/.... Table IDs start with tbl, but table names work in the API too.

Two limits shape every script: the API returns at most 100 records per page, and it allows 5 requests per second per base. Over that, you get HTTP 429 and have to wait about 30 seconds.

Method 1: a Node.js script against the Web API

The list-records endpoint is GET https://api.airtable.com/v0/{baseId}/{tableIdOrName}. When a table has more than 100 records, the response includes an offset string. Pass it back as a query parameter to get the next page. When offset is missing, you're done.

This script (Node 18+, no dependencies) loops until offset disappears, backs off on 429s, and writes everything to export.json:

// export.mjs: dump every record of one Airtable table to JSON
import { writeFileSync } from "node:fs";

const { AIRTABLE_TOKEN, BASE_ID, TABLE } = process.env;
const url = `https://api.airtable.com/v0/${BASE_ID}/${encodeURIComponent(TABLE)}`;
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const records = [];
let offset;
do {
  const qs = new URLSearchParams({ pageSize: "100" });
  if (offset) qs.set("offset", offset);

  const res = await fetch(`${url}?${qs}`, {
    headers: { Authorization: `Bearer ${AIRTABLE_TOKEN}` },
  });
  if (res.status === 429) {          // rate limited: wait, retry the same page
    await sleep(30_000);
    continue;
  }
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);

  const page = await res.json();
  records.push(...page.records);
  offset = page.offset;              // undefined on the last page
  await sleep(250);                  // stay under 5 requests/second
} while (offset);

writeFileSync("export.json", JSON.stringify(records, null, 2));
console.log(`Saved ${records.length} records`);

Run it like this:

AIRTABLE_TOKEN=patXXXX BASE_ID=appXXXX TABLE=Clients node export.mjs

Each record looks like this:

{
  "id": "rec2rIP4G7xcj21oe",
  "createdTime": "2026-10-21T14:51:28.000Z",
  "fields": {
    "Name": "Acme, Inc.",
    "Status": "Active",
    "Monthly fee": 1200
  }
}

Useful query parameters: view=Grid%20view limits the export to what a view shows (including its filters and sort order), fields[]=Name&fields[]=Email returns only those columns, and filterByFormula filters server-side. For a whole base, call the script once per table.

Get the schema too

A records dump doesn't tell you field types, which matters if you ever re-import the data. The Meta API returns them:

curl -s -H "Authorization: Bearer $AIRTABLE_TOKEN" \
  "https://api.airtable.com/v0/meta/bases/$BASE_ID/tables"

The response lists every table with its ID, fields (name, ID, type, options) and views. That's also how you get a list of table names to loop over. If you'd rather not write code for this part, there's a browser-based Airtable schema export tool.

Method 2: curl and jq

If you have a shell and jq, you don't need Node. The pagination loop is short:

#!/usr/bin/env bash
# export.sh: needs AIRTABLE_TOKEN, BASE_ID, TABLE
set -euo pipefail
URL="https://api.airtable.com/v0/$BASE_ID/$TABLE"
OFFSET=""
while :; do
  RESP=$(curl -sS -H "Authorization: Bearer $AIRTABLE_TOKEN" \
    "$URL?pageSize=100${OFFSET:+&offset=$OFFSET}")
  echo "$RESP" | jq -c '.records[]'                  # one record per line
  OFFSET=$(echo "$RESP" | jq -r '.offset // empty')   # empty on the last page
  [ -z "$OFFSET" ] && break
  sleep 0.25                                          # stay under 5 req/s
done | jq -s '.' > export.json

The trick is ${OFFSET:+&offset=$OFFSET}: the &offset= part is only added when OFFSET is non-empty, so the first request has no offset. The loop prints one JSON record per line, and jq -s slurps them into a single array at the end.

For a single page (up to 100 records), you can skip the loop. This one flattens each record so the fields sit next to the ID:

curl -s -H "Authorization: Bearer $AIRTABLE_TOKEN" \
  "https://api.airtable.com/v0/$BASE_ID/Clients?pageSize=100" \
  | jq '[.records[] | {id} + .fields]'

A flat array like that is usually easier to feed into other tools than the nested {id, createdTime, fields} shape.

Method 3: a no-code tool in the browser

If you don't want to touch a terminal, use the Airtable to JSON tool. It runs entirely in your browser: you paste a personal access token, pick a base and table, and it handles the pagination and rate limit for you. Your token is used for requests from your browser to Airtable and never goes to a server.

You can choose between:

• Full JSON, the same {id, createdTime, fields} structure the API returns.
• Flat JSON, one plain object per record, with the field values at the top level.

Then copy the result or download it as a file. It's the quickest option for a one-off export of a single table. For anything you need to repeat or automate, use Method 1 or 2.

Gotchas that surprise people

The JSON you get is the raw API view of your data, not a mirror of the grid. These are the usual surprises:

• Linked records are record IDs. A "Clients" link in an "Orders" table comes back as ["rec123...", "rec456..."], not names. To resolve them, export the linked table too and join on id. Or add a lookup field in Airtable that pulls the name through.
• Lookups and rollups are arrays, even when there's only one value. A lookup of a single number is [42], not 42. Multi-select and collaborator fields are arrays too.
• Empty fields are omitted. If a cell is empty (or a checkbox is unchecked), the key isn't in fields at all. Don't assume every record has every key. In Node, use record.fields.Email ?? "". In jq, use .Email // "". Build your column list from the schema, not from the first record.
• Attachment URLs expire. Each attachment has a url that stops working after a few hours. If your JSON is a backup, download the files right away, or you'll end up with dead links. This is the same reason exported CSV attachment links stop working.
• Views are only honored if you ask. Without view=..., you get every record in the table in the table's default order, not what a filtered view shows.
• Formula and computed fields can fail per record. They may come back as an error object such as {"error": "#ERROR!"} instead of a value. Check for that before parsing.

Which one should you use?

• A script you'll run again, or a backup in CI: Method 1.
• Quick, scriptable, nothing to install on most Linux and macOS machines (apart from jq): Method 2.
• A one-time dump and you don't want to write code: Method 3.

One more thing

JSON is the right format when another program reads the data. If what you need is the opposite, a recurring CSV or Excel file of one view landing in someone's inbox without anyone running scripts, that's what ViewCourier does, and there's a walkthrough of the options in how to email an Airtable view on a schedule.

ViewCourier is not affiliated with Airtable. Airtable is a trademark of its owner.

Airtable keeps your data safe on its side, but that is not the same as having your own copy. A deleted table, a bad bulk edit or a lost workspace login can still ruin your week. Snapshots and the trash help for a limited time. A copy you hold yourself does not expire.

A complete backup of a base has three parts, and most people only save the first:

1. Records: the data in every table, not just one view.
2. Schema: the table structure, field types, select options, formulas and linked tables. Without it, a pile of CSVs is hard to rebuild.
3. Attachments: the actual files. A CSV only contains links to them.

Here are four ways to do this for free, from quick to automated.

1. The manual way: download CSV per view

In Airtable, open a view, click the view name, then Download CSV. It works, but has limits:

• It exports one view at a time. If the view has filters or hidden fields, the CSV has them too, so you can silently miss records or columns.
• You have to repeat it for every table and every time you want a fresh copy.
• Attachments come out as URLs, not files.
• Nothing is saved about the structure: no field types, no formulas, no select options.

For a one-table base you check once a month, this is fine. For anything bigger, use one of the next options.

2. Free browser tools that run client-side

If you don't want to write code, these tools run entirely in your browser. You paste an Airtable personal access token, and the requests go from your browser straight to api.airtable.com. Nothing goes through a server and nothing is stored.

First, create a read-only personal access token at airtable.com/create/tokens. Give it the scopes data.records:read and schema.bases:read, and add only the base you want to back up. Delete the token when you are done.

Then:

• Base to CSV downloads every table as its own CSV, all records and all fields, bundled in one ZIP.
• Schema export gives you a data dictionary as CSV, Markdown or raw JSON. It only needs schema.bases:read, so the token cannot read your records.
• Attachment downloader downloads every file in a table or view as a ZIP, one folder per record, plus a manifest CSV.
• Record counter shows how many records each table has and how close you are to your plan's limit. It also lists which fields are never filled in. Handy before you decide what is worth backing up.

Run them in that order: schema, CSVs, attachments. On a base with a few thousand records the whole thing takes a few minutes.

3. A script you control

If you prefer to own the whole process, the Airtable REST API is simple. Three facts matter:

• A list request returns at most 100 records per page. If the response contains an offset, send it back to get the next page.
• Airtable allows about 5 requests per second per base, so pause between pages.
• Attachment URLs expire after about two hours. Download the files in the same run that fetched the records. A URL saved in last month's CSV will not work anymore (more on that in this guide on expired attachment links).

This Node.js script (version 18 or newer, no dependencies) saves the schema, every table as JSON, and every attachment:

// backup.mjs: AIRTABLE_TOKEN=pat... BASE_ID=app... node backup.mjs
import { mkdir, writeFile } from "node:fs/promises";

const { AIRTABLE_TOKEN: token, BASE_ID: base } = process.env;
const api = "https://api.airtable.com/v0";
const headers = { Authorization: `Bearer ${token}` };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function get(url) {
  const res = await fetch(url, { headers });
  if (res.status === 429) { await sleep(30000); return get(url); }
  if (!res.ok) throw new Error(`${res.status} ${url}`);
  return res.json();
}

const stamp = new Date().toISOString().slice(0, 10);
const dir = `backup-${stamp}`;
await mkdir(`${dir}/files`, { recursive: true });

// 1. Schema
const schema = await get(`${api}/meta/bases/${base}/tables`);
await writeFile(`${dir}/schema.json`, JSON.stringify(schema, null, 2));

// 2. Records, page by page
for (const table of schema.tables) {
  const records = [];
  let offset;
  do {
    const qs = new URLSearchParams({ pageSize: "100" });
    if (offset) qs.set("offset", offset);
    const page = await get(`${api}/${base}/${table.id}?${qs}`);
    records.push(...page.records);
    offset = page.offset;
    await sleep(250);
  } while (offset);
  await writeFile(`${dir}/${table.name}.json`, JSON.stringify(records, null, 2));

  // 3. Attachments, right away while the URLs are valid
  for (const rec of records) {
    for (const value of Object.values(rec.fields)) {
      if (!Array.isArray(value)) continue;
      for (const f of value) {
        if (!f?.url || !f?.filename) continue;
        const file = await fetch(f.url);
        if (!file.ok) { console.warn("skipped", f.filename); continue; }
        await writeFile(`${dir}/files/${rec.id}-${f.id}-${f.filename}`,
          Buffer.from(await file.arrayBuffer()));
      }
    }
  }
  console.log(`${table.name}: ${records.length} records`);
}

Two notes. The JSON keeps linked records, lookups and multi-selects exactly as Airtable returns them, which is more faithful than CSV. If you want CSV for spreadsheets, convert the JSON afterwards or use the browser tool from section 2. And the script lives on your machine, so the token never leaves it. Keep the token in an environment variable, not in the file.

4. Make it happen on a schedule

A backup you have to remember is a backup that stops. Some options for automating it:

• Cron or a scheduled GitHub Action running the script above, committing or uploading the output to storage you control. The most flexible option, and you maintain it.
• An Airtable automation with a scheduled trigger that runs a script or sends a webhook. It works inside Airtable's own limits, and the free plan has few automation runs.
• Make or Zapier with a schedule trigger that lists records and writes them to Drive or Dropbox. Fine for small bases, but watch the operation counts.
• Emailing a view as CSV: if what you need is a regular CSV of one view in your inbox, ViewCourier does this on a daily, weekly or monthly schedule, with a free plan. It exports views, so it is a good fit for key tables rather than a full base dump with attachments.

There is a step-by-step version of the CSV route in this guide to automatic Airtable CSV backups. I also compared three ways of scheduling CSV emails in this write-up.

A sensible routine

• Once now: run the schema export and the full-base CSV export, store the ZIPs somewhere that is not Airtable.
• Weekly or monthly: a scheduled script or emailed view CSVs for the tables that change.
• Before big changes: run the tools again. A fresh copy takes minutes.
• Test a restore once. Open a CSV, check that linked records and dates look right, and check that the schema file tells you what each field was.

The one habit that matters is keeping the copy outside the system it is backing up.

Disclosure: written by the team behind ViewCourier.