Generate PDFs from Airtable — Automate Documents with Typsetter

The Airtable document problem

You have an Airtable base with hundreds of client records, invoice data, or course completions. You need to generate PDFs from that data — invoices, contracts, certificates, reports. Airtable has no native PDF generation. The Page Designer extension is limited, poorly styled, and cannot be triggered programmatically.

Most teams end up copy-pasting data into Google Docs or Word templates, one record at a time. Others try building a custom solution with Puppeteer or wkhtmltopdf, which means managing a server, a headless browser, and a fragile HTML template system. Neither approach scales.

Typsetter solves this with a REST API that accepts JSON data and returns a PDF in ~340ms. You design your template once in the Typsetter dashboard, then send data from Airtable through any of the three methods below.

Three ways to connect Airtable to Typsetter

Each method has different trade-offs. Choose based on your technical comfort level and how much control you need.

Zapier — zero code, trigger-based automation, best for simple workflows
Make (formerly Integromat) — visual builder with HTTP modules, more flexibility than Zapier
Airtable Scripting — full JavaScript control inside Airtable, best for complex logic and batch processing

Method 1: Zapier — no-code automation

Zapier is the fastest way to connect Airtable to Typsetter if you want zero code. The flow: a new record appears in Airtable (or an existing record is updated), Zapier maps the fields to your Typsetter template variables, calls the API, and optionally attaches the generated PDF back to the Airtable record.

Step-by-step setup

Create a Zap with the trigger "New or Updated Record in Airtable". Select your base and table. Add a filter if you only want to generate PDFs for records where a specific field (e.g., "Status") equals "Ready to send".

Add a Typsetter action step (or use Webhooks by Zapier). If using the Typsetter Zapier integration, select "Generate PDF" and authenticate with your API key. If using Webhooks, configure a POST request to https://api.typsetter.dev/v1/render.

Map your Airtable fields to template variables. For example, map the "Client Name" column to client_name, "Invoice Number" to invoice_number, and "Line Items" to the items array in your template.

Add a final step to attach the PDF back to Airtable. Use the "Update Record" action in Airtable to upload the PDF file URL to an Attachment field. The Typsetter response includes a download_url that Airtable can consume directly.

Tip

Use Zapier's built-in formatter to transform Airtable date fields into the format your template expects (e.g., "March 23, 2026" instead of "2026-03-23"). This avoids needing date formatting logic in your Typst template.

Method 2: Make (Integromat) — visual HTTP workflow

Make gives you more control than Zapier, especially for workflows that involve conditional logic, loops over line items, or error handling. The HTTP module lets you call the Typsetter API directly with full control over the request body.

Step-by-step setup

Create a new scenario with the "Watch Records" Airtable module. Select your base, table, and the trigger field. Make will poll Airtable at your chosen interval (every 5, 10, or 15 minutes on the free plan).

Add an HTTP "Make a request" module. Set the URL to https://api.typsetter.dev/v1/render, method to POST, and add your Authorization: Bearer ts_live_sk_YOUR_KEY header. Set the body type to JSON.

Build the JSON body using Make's visual mapper. Map each Airtable field to the corresponding template variable. For arrays (like invoice line items), use Make's array aggregator module to transform linked records into the JSON array your template expects.

Add an Airtable "Update a Record" module to attach the PDF. Parse the Typsetter response with a JSON parser module, extract the download_url, and write it to an Attachment field on the original record.

Why Make over Zapier?

Make's array aggregator is essential if your Airtable base uses linked records for line items. Zapier struggles with dynamic-length arrays. Make also supports error handling routes, so you can log failures to a separate Airtable table instead of silently dropping records.

Method 3: Airtable Scripting — full control

Airtable's Scripting extension (or the "Run a script" action in Airtable Automations) gives you a full JavaScript runtime inside Airtable. This is the most powerful approach: you can query multiple tables, apply complex business logic, handle errors, and process records in bulk — all without leaving Airtable.

The script

Paste this into an Airtable Scripting extension or an Automation's "Run a script" action. It reads records from a table, sends each to Typsetter, and writes the PDF URL back.

Airtable Scripting — Generate PDFs from records
// Configuration
const API_KEY = 'ts_live_sk_YOUR_KEY';
const TEMPLATE = 'invoice-professional';
const TABLE_NAME = 'Invoices';
const PDF_FIELD = 'PDF Attachment';

// Fetch records that need PDFs generated
const table = base.getTable(TABLE_NAME);
const query = await table.selectRecordsAsync({
  fields: ['Client Name', 'Invoice Number', 'Date',
           'Line Items', 'Total', 'Status', PDF_FIELD]
});

// Filter to records marked "Ready" that don't already have a PDF
const pending = query.records.filter(r =>
  r.getCellValueAsString('Status') === 'Ready' &&
  !r.getCellValue(PDF_FIELD)
);

output.text(`Found ${pending.length} records to process...`);

for (const record of pending) {
  const data = {
    client_name: record.getCellValueAsString('Client Name'),
    invoice_number: record.getCellValueAsString('Invoice Number'),
    date: record.getCellValueAsString('Date'),
    total: record.getCellValue('Total'),
  };

  const response = await fetch(
    'https://api.typsetter.dev/v1/render', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      template: TEMPLATE,
      format: 'pdf',
      data: data,
    })
  });

  if (!response.ok) {
    output.text(`Failed: ${data.invoice_number} — ${response.status}`);
    continue;
  }

  const result = await response.json();

  // Attach the PDF URL back to the Airtable record
  await table.updateRecordAsync(record.id, {
    [PDF_FIELD]: [{ url: result.download_url }],
    'Status': { name: 'PDF Generated' },
  });

  output.text(`Generated: ${data.invoice_number}`);
}

output.text(`Done. Processed ${pending.length} records.`);

Batch processing

This script processes records sequentially. For large batches (100+ records), consider using Typsetter's native CSV batch endpoint instead: export your Airtable view as CSV, upload it to /v1/batch, and get a ZIP of all PDFs back in a single request.

Using it in Airtable Automations

To make this fully automatic, create an Airtable Automation with a "When record matches conditions" trigger (e.g., Status = "Ready"). Add a "Run a script" action with a simplified version of the code above that processes only the triggering record via input.config(). The PDF generates within seconds of the status change — no human intervention required.

Airtable Automation — single record trigger
// Inside "Run a script" action — input config maps the trigger record fields
const config = input.config();

const response = await fetch('https://api.typsetter.dev/v1/render', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer ts_live_sk_YOUR_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    template: 'invoice-professional',
    format: 'pdf',
    data: {
      client_name: config.clientName,
      invoice_number: config.invoiceNumber,
      date: config.date,
      total: config.total,
    }
  })
});

const result = await response.json();

// Output the download URL for the next automation step
output.set('pdfUrl', result.download_url);

Use cases

The Airtable + Typsetter combination works for any scenario where structured data needs to become a formatted document. Here are the three most common patterns.

Invoices from a CRM

Your sales team manages deals in Airtable. When a deal closes, an automation generates a branded PDF invoice with line items, tax calculations, and payment terms — then emails it to the client and logs it in the record.

Certificates from a course tracker

Students complete courses tracked in Airtable. When a record's "Completed" checkbox is ticked, a certificate PDF with the student's name, course title, and completion date is generated and attached to the record automatically.

Contracts from a client database

Your client onboarding base stores names, addresses, and service terms. A button or automation generates a personalized contract PDF pre-filled with all the client's details, ready for signature via DocuSign or HelloSign.

Tips and best practices

Structure your Airtable base for automation

Add a Status field (single select) with values like "Draft", "Ready", "PDF Generated", and "Sent". Use this field as the trigger condition for your automations. This gives you a clear audit trail and prevents duplicate generation.

Handle line items with linked records

If your invoices have variable-length line items, store them as linked records in a separate "Line Items" table. In the Airtable script, query the linked records and build the items array dynamically. Typsetter templates handle arrays natively — use a {% for item in items %} loop in your Typst/Tera template.

Store the API key securely

In Airtable Automations, you can use the input.config() mechanism to pass the API key as a secret from the automation configuration rather than hardcoding it in the script. In Zapier and Make, use the built-in credential storage.

Test with the preview endpoint first

Before wiring up the full automation, test your template with Airtable data using the Typsetter preview endpoint. Send a single record's data to /v1/render with "format": "png" to get a quick visual preview. This catches field mapping issues before they affect production records.

Use webhooks for real-time triggers

If you need instant PDF generation (not Zapier's 1–15 minute polling delay), use Airtable Automations with the "Run a script" action. Automations trigger within seconds of a record change, giving you near-real-time document generation.

Rate limits

Airtable Scripting allows up to 50 fetch calls per script execution. If you need to process more than 50 records at once, use Typsetter's CSV batch endpoint or split the work across multiple automation runs.

Start generating PDFs from Airtable today

The fastest path: sign up for a free Typsetter account, pick an invoice or certificate template from the template store, and paste the Airtable Automation script above into a "Run a script" action. You will have automatic PDF generation running in under 15 minutes.

For more complex setups involving multiple tables, conditional templates, or multi-page documents, the Zapier and Make integrations give you visual workflow builders that non-technical team members can maintain. And if you outgrow those, the Airtable Scripting approach gives you full programmatic control without leaving the Airtable ecosystem.

Try Typsetter for free

100 PDFs/month on the free plan. API key in 30 seconds. No credit card required.

Get Your Free API Key → View API Docs