DEV Community: ViewCourier

How to back up an Airtable base for free (CSV, schema and attachments)

ViewCourier — Thu, 22 Oct 2026 10:21:06 +0000

Disclosure: this article was written with the help of AI and checked against Airtable's docs and API before publishing.

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:

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

Here are three 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. A script you control

If you prefer to own the whole process, the Airtable REST API is simple. 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. 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.

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. And the script lives on your machine, so the token never leaves it. Keep the token in an environment variable, not in the file.

3. 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.
Paid add-ons and third-party export or backup services can run scheduled exports for you, usually with a free tier or a subscription. Check what they cover: many export views or single tables rather than a full base with attachments, so a script like the one above is still the most complete option.

A sensible routine

Once now: run the backup script and store the output somewhere that is not Airtable.
Weekly or monthly: a scheduled run of the script for the tables that change.
Before big changes: run the script again. A fresh copy takes minutes.
Test a restore once. Open a few of the JSON files, 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.

How to email an Airtable view as a CSV on a schedule (3 ways)

ViewCourier — Wed, 21 Oct 2026 17:58:20 +0000

Disclosure: this article was written with the help of AI and checked against Airtable's docs and API before publishing.

A common Airtable request: "Every Monday at 8:00, email this view to my manager (or client, or accountant) as a CSV." Airtable lets you download a view as CSV by hand from the view menu. It does not let you schedule that download, and its automations cannot attach a CSV of a view to an email. So you need a workaround.

Here are three, from most hands-on to least.

Before you start: make an export view

Whatever method you pick, create a dedicated view for the export, for example Export - do not edit. Filter it to the rows the recipient should see, hide fields they shouldn't, and sort it the way people will read it. Every method below reads from that view.

Option 1: Airtable automation + script

Airtable automations have a scheduled trigger (At a scheduled time) and a Run script action. A script can read a view and build CSV text:

const table = base.getTable('Orders');
const view = table.getView('Export - do not edit');
// List the columns you want, in order. Scripting can't read which fields a view hides.
const fields = ['Order ID', 'Customer', 'Status', 'Total'].map((n) => table.getField(n));
const query = await view.selectRecordsAsync({ fields });

function cell(v) {
  let s = v == null ? '' : String(v);
  if (/^[=+\-@\t\r]/.test(s) && isNaN(Number(s))) s = "'" + s; // formula-injection guard
  return /[",\r\n]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s;
}

const rows = [fields.map((f) => cell(f.name)).join(',')];
for (const r of query.records) {
  rows.push(fields.map((f) => cell(r.getCellValueAsString(f))).join(','));
}
const csv = '' + rows.join('\r\n'); // BOM so Excel reads UTF-8
output.set('rowCount', query.records.length);

What this gets right:

selectRecordsAsync on a view applies that view's filters and sort, with no 100-record page limit.
getCellValueAsString gives the same text you see in the grid for linked records, lookups, dates and selects.
Values with commas, quotes or line breaks are quoted, and text starting with =, +, - or @ is prefixed so spreadsheets don't run it as a formula.
The leading byte-order mark stops Excel on Windows from garbling accents.

Now the hard part: getting csv into an inbox as a file.

The built-in Send email action can't attach it. There is no automation action that turns text or records into a file attachment. Airtable's own support docs point to third-party tools for this.
Pasting records into the email body is capped. According to Airtable's support article on Find records, a list or grid of records inserted into an automated email shows at most 100 records. A view with 400 rows arrives with the first 100 and no warning.
So the script has to send the email itself. You fetch an email API (SendGrid, Mailgun, Postmark) and pass the CSV as a base64 attachment. That means a second account, an API key stored in your base, and your own error handling.
You maintain the column list. Add a field to the view and the CSV doesn't change until someone edits the script.
Scripts have time and memory limits, and Run script in automations requires a paid Airtable plan.

Good fit if: you're comfortable with JavaScript, already have an email API account, and the view is small and stable.

Option 2: Make or Zapier

The usual community answer. The scenario looks like this:

Schedule trigger: every Monday at 08:00.
Airtable: Search records in your export view. Set the record limit high enough and hope the view doesn't outgrow it.
Iterator / aggregator to turn records into CSV text. Each column is mapped by hand.
Create file from the text, with a file name and type.
Gmail / Outlook / SMTP: send email with the file attached.

It works, and it's the right choice when the export is one step in a bigger workflow (export, then upload to SFTP, then post to Slack).

The costs to know about:

Operations add up per record. On Make, every record that passes through a module typically counts as an operation. A 2,000-row weekly export can use thousands of operations a month. Zapier's per-task billing has the same effect when you loop over records. Check your plan's quota before you build.
Manual column mapping, same as the script: new fields don't appear until the scenario is edited.
Edge cases are yours: quoting commas and line breaks, UTF-8 for Excel, Airtable's 100-records-per-page API paging and its limit of 5 requests per second per base.
The email comes from a connected mailbox, which ties the report to one person's login.

Option 3: A dedicated export service

Paid Airtable add-ons and third-party export or backup services exist that do only this job: send a view as a file to a list of recipients on a schedule, without you writing or maintaining a script. Compare them on a few points before you pick one:

Access scope: can you give it a read-only personal access token limited to the bases you choose?
Row limits: does it page through the whole view, and what happens when the view is larger than the plan allows?
File size: large CSVs may be zipped or replaced by a download link, so check how big files are handled.
Failure handling: what happens when a token is revoked or a view is deleted, and who gets told?
Price: many are subscription-based and charge by the number of exports or rows.

Good fit if: you want a fixed view delivered on a fixed schedule and would rather pay than maintain code.

Which one to pick

Small view, you like code, you already have an email API: the script.
The export is part of a larger workflow: Make or Zapier.
You just want "this view, as a file, in these inboxes, on this schedule": a dedicated third-party export service (Option 3).

Questions about any of the three approaches are welcome in the comments.