# How to add Image and PDF Attachment Automations in Airtable

> Automatically add branded image and PDF attachments to Airtable records. Render via a script or Make, Zapier, or n8n and write the file back. 30 free credits.

- **Author**: Rishi Mohan
- **Published**: 2026-06-16
- **Tags**: Airtable, Automation, Attachments, PDF, Tutorials
- **Read time**: 7 min read
- **URL**: https://orshot.com/blog/airtable-image-automation

---

Airtable is great at holding data — testimonials, products, listings, events. It's just not built to turn that data into finished graphics. So the work lands on you: export to a sheet, open Canva, rebuild the same layout for every row.

This is about automating that away. Design the layout once in Orshot, point an [Airtable automation](https://www.airtable.com/platform/automations "target=_blank rel=nofollow") at it, and every record renders itself into a branded image or PDF — with the file written straight back into an attachment field.

Quick expectation-check, since "images from Airtable" gets used two ways:

- **AI art from a prompt** — type "a watercolor fox," get a fox. That's a text-to-image model, not this.
- **Designed graphics and PDFs from your records** — every row becomes an on-brand card, certificate, or social post. That's what we're doing, basically [template-based graphics from your Airtable data](https://orshot.com/blog/template-based-image-generation-tools).

[**Try it on your own base free**](https://orshot.com/pricing "target=_blank") **— 30 credits, no card.**

## What you'll build

Here's the end state. This is a testimonials table where every quote rendered itself into a branded review card, dropped right into the Attachments field:

![An Airtable testimonials table where each quote has rendered into a branded review card in the Attachments column](https://orshot.com/blog/airtable-image-automation/04-airtable-result.webp)

Same idea works for product cards, event banners, listing graphics, or per-record certificates — you template the design once, then every row fills it in.

## Step 1 — your table

You need a **Quote** column for the text and an **Attachments** field for the finished card. Add a column for anything else each card should pull from your data — a name, a company, a stat — then map it in the next step.

## Step 2 — a template

The Attachments column fills from an Orshot template — the design your rows pour into. This is the review card open in [Studio](https://orshot.com/features/orshot-studio), with the quote, stat, photo, and name all set up as fields:

![The review-card template open in Orshot Studio, with the quote, stat, photo, and customer fields](https://orshot.com/blog/airtable-image-automation/05-studio-template.webp)

Build your own from scratch, generate one with AI, or paste a Canva link and start from that:

Mark the parts you want driven by data — the quote, a name, a stat — as dynamic, and you're ready to wire it up.

## Step 3 — the render

This is the part that calls Orshot and writes the card back. In Airtable it runs in the Scripting extension (fired by a button) or an Automation's _Run a script_ action — both are on Airtable's paid (Team) plans. On the Free plan, skip to the [no-code route](#no-code-make-zapier-or-n8n) below; it works on any plan.

You don't have to write the script from scratch. Open your template, hit **Automate → Airtable**, and Orshot hands you a ready-made script for that template with its fields already mapped — here's a trimmed version that drives the card from a couple of columns:

![Orshot's Quick Connect sheet on the Airtable tab — the ready-made Airtable Scripting code for this template](https://orshot.com/blog/airtable-image-automation/06-quick-connect-airtable.webp)

It reads a row, sends its fields to Orshot, and saves the returned file to the attachment field:```javascript
// Airtable script — render a review card from each row
const table = base.getTable("Testimonials");
const record = await input.recordAsync("Pick a record", table);

const res = await fetch("https://api.orshot.com/v1/studio/render", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_ORSHOT_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    templateId: "your_template_id",
    modifications: {
      // map each column to a field in your template
      quote: record.getCellValueAsString("Quote"),
      customer_name: record.getCellValueAsString("Customer"),
      customer_title: record.getCellValueAsString("Title"),
      // add company, stat_number, stat_label, customer_photo to drive the rest
    },
    response: { type: "url", format: "png" }, // "pdf" gives a document instead
  }),
});

const { data } = await res.json();
await table.updateRecordAsync(record, { Attachments: [{ url: data.content }] });
````modifications` maps your columns onto the template. The render comes back as a hosted URL, and `updateRecordAsync` drops it into the Attachments field — that attachment URL is what shows the card right in the record — the same card you saw up top. (Quick Connect names the field `Orshot Image`; I used Airtable's default `Attachments` — use either, just match it in the script, and keep your key in the script's secrets, not in a shared base.)

## No-code: Make, Zapier, or n8n

On a Free Airtable plan, or if you'd rather not touch code, wire it up in a no-code tool instead. Orshot connects to Zapier, Make, n8n, and Pipedream directly:

![Orshot's no-code connectors — Airtable, Zapier, Make, n8n, and Pipedream](https://orshot.com/blog/airtable-image-automation/01-integrations.webp)

The recipe's the same in all of them:

- **Trigger** — a new or updated Airtable record
- **Render** — send the fields to an Orshot render step
- **Write back** — update the record with the URL that returns

Full walkthroughs for [Make](https://orshot.com/blog/orshot-make-integration) and [n8n](https://orshot.com/blog/n8n-marketing-automation-tutorial). If you've built a [Sheets-to-image flow](https://orshot.com/blog/auto-generate-instagram-carousels-google-sheets) before, this is the same shape against your base.

## Then let it run

One render is a demo. The point is never thinking about it again. With the [content automation](https://orshot.com/solutions/content-automation-platform) in place, every new row turns itself into a finished file — like this base quietly rendering content and listings on its own:

![Orshot Automations — Airtable records turning into images and PDFs automatically](https://orshot.com/blog/airtable-image-automation/02-automations.webp)

A few things worth knowing:

- **PDFs, not just images** — switch `format` to `pdf` and the same template becomes a per-record certificate, invoice, or one-pager. `mp4` gives you a short clip.
- **Backfill** old rows by looping the script over a view, or batch the whole set at once
- **It scales** — renders run in parallel, so a big batch doesn't crawl

[**Point it at your base →**](https://orshot.com/pricing "target=_blank") — free, 30 credits, no card.

## Common questions

**Q: Is this an Airtable automation, or do I click a button?**

Both work, on a paid Airtable plan: the Scripting extension fires on a button click, and Airtable's Automations can run the same script on a 'record created' or 'record updated' trigger. On any plan — including Free — Make, Zapier, or n8n can watch the base and render automatically.

**Q: Can Orshot make AI art from an Airtable prompt field?**

No. Orshot renders from templates, not text prompts — it turns your records into branded graphics, it doesn't invent artwork. For DALL·E-style art, use a text-to-image model. Orshot does use AI to [build a starting template](https://orshot.com/features/ai-template-generator) and for background removal, but the render itself is template-based.

**Q: Can it generate PDFs, not just images?**

Yes — set the response format to `pdf` and the same template renders a document instead of an image. It's how people generate per-record certificates, invoices, and one-pagers. Video (mp4/webm/gif) works the same way. See the [render API](https://orshot.com/solutions/image-generation-api).

**Q: How does the finished file get back into Airtable?**

Orshot returns a hosted URL. You write it into an Airtable attachment field on the same record — that attachment URL is what displays the rendered card in the cell. The script's updateRecordAsync step, or the automation's 'Update record' action, does it for you.

**Q: Do I have to write the script myself?**

No. Every Orshot template has a Quick Connect sheet — open it and hit the Airtable tab, and you get the Scripting snippet with all of that template's fields already mapped. Copy, paste, swap in your API key.

**Q: Can I run it across thousands of existing records?**

Yes. Loop the script over a view, batch the set, or use Orshot's bulk render to backfill. Renders run in parallel, so large jobs stay quick.

## Bottom line

If you meant AI art, grab a text-to-image model — Orshot isn't that.

If you meant automating Airtable to spit out clean, designed images and PDFs from the records you already keep, that's the whole job: template the design once, connect it through a script or a no-code automation, and every row renders its own.

The same approach works from [Google Sheets](https://orshot.com/blog/auto-generate-instagram-carousels-google-sheets) and most data sources. Try it on the free credits, and if the field mapping trips you up, hit the chat — I'll walk you through it.