---
title: "Airtable Image Generation: Rows to Images"
description: "Turn Airtable rows into images automatically. Perfect for product catalogs, team directories, and content libraries. Step-by-step integration guide."
url: "https://www.imejis.io/blogs/integrations/airtable-image-generation"
published: "2026-02-17"
---

# Airtable Image Generation: Rows to Images

My friend runs an e-commerce store with 400 products. Every product needs a social media image. Different image for Instagram, different one for Pinterest, another for the website.

She was updating these manually. In Canva. One by one.

Her product data already lived in [Airtable](https://airtable.com). Prices, descriptions, photos, everything. The problem was getting that data into images without copying and pasting for hours.

That's exactly what Airtable image generation solves. Your database rows become images automatically. Update a price in Airtable, and the product image updates itself.

Here's how to set it up.

## Why Airtable + Image APIs Work So Well

Airtable is basically a spreadsheet that acts like a database. Most businesses already use it for:

- Product catalogs
- Team directories
- Content calendars
- Client databases
- Inventory management

All that data is sitting there, organized and ready. An image API just needs to read it and generate visuals.

**What this enables:**

| Use Case        | Airtable Data        | Generated Image           |
| --------------- | -------------------- | ------------------------- |
| Product catalog | Name, price, photo   | Product card with pricing |
| Team directory  | Name, role, headshot | Employee profile card     |
| Event schedule  | Speaker, topic, time | Session announcement      |
| Real estate     | Address, price, beds | Property listing card     |
| Social content  | Quote, author, topic | Quote graphic             |

The pattern is always the same: structured data becomes visual content.

## The Architecture

Here's how the pieces connect:

```text
Airtable (your data) → Automation trigger → Image API → Generated image → Back to Airtable (or anywhere)
```

You have three options for the automation layer:

1. **Airtable Automations** (built-in, limited)
2. **[Zapier](/blogs/zapier-integration-generate-dynamic-images)** (easiest, most flexible)
3. **Custom script** (most control)

I'll cover all three. Pick the one that fits your technical comfort level.

## Method 1: Zapier Integration (Easiest)

This is the path for most people. No code required.

### Step 1: Set Up Your Airtable Base

Your base needs columns for every piece of data that goes into the image:

| Column Name    | Type             | Example               |
| -------------- | ---------------- | --------------------- |
| Product Name   | Single line text | "Wireless Headphones" |
| Price          | Currency         | $149.99               |
| Product Image  | Attachment       | Photo URL             |
| Generated Card | URL              | (Zapier fills this)   |

The "Generated Card" column will store the final image URL after generation.

### Step 2: Create Your Template in Imejis.io

Design a template with editable fields matching your Airtable columns:

1. Go to [Imejis.io](https://www.imejis.io) and create a new design
2. Add text elements for product name and price
3. Add an image element for the product photo
4. Mark each element as "editable" in the properties panel
5. Name the fields: `product_name`, `price`, `product_image`

These field names are what Zapier will use to send data.

### Step 3: Build the Zap

**Trigger:** New or Updated Record in Airtable

Configure:

- Select your base and table
- Choose which view to watch (optional)

**Action:** Generate Image in Imejis.io

Configure:

- Select your template
- Map Airtable fields to template fields:
  - `product_name` → Product Name column
  - `price` → Price column
  - `product_image` → Product Image column (use the URL)

**Action:** Update Record in Airtable

Configure:

- Same base and table
- Record ID from trigger
- Set "Generated Card" field to the image URL from Imejis.io

### Step 4: Test and Activate

Add a test record to your Airtable. Watch the Zap run. If everything's connected right, your "Generated Card" column will have a URL to your new product image.

Now every new product you add gets an image automatically.

## Method 2: Airtable Automations + Webhooks

Airtable has built-in automations. They're more limited than Zapier but keep everything in one place.

### Set Up the Automation

1. In Airtable, go to Automations
2. Create new automation
3. Trigger: "When record matches conditions" (or "When record created")
4. Action: "Run a script"

### The Script

```javascript
const config = input.config()
const record = config.record

// Get field values
const productName = record.getCellValue("Product Name")
const price = record.getCellValue("Price")
const productImage = record.getCellValue("Product Image")

// Get the image URL from the attachment
const imageUrl = productImage ? productImage[0].url : null

// Call Imejis.io API - returns image directly
const response = await fetch("https://render.imejis.io/v1/YOUR_TEMPLATE_ID", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    product_name: productName,
    price: `$${price}`,
    product_image: imageUrl,
  }),
})

// Response is the image binary - upload to your storage
const imageBlob = await response.blob()

// Output for next automation step
output.set("imageGenerated", true)
```

Add another action after the script to update the record with the generated URL.

### Limitations

Airtable's scripting has some restrictions:

- Limited execution time
- Can't install external packages
- API calls must complete quickly

For simple image generation, it works fine. For complex workflows, Zapier or custom code is better. You can also use [Make.com (Integromat)](/blogs/integrations/make-integromat-image-automation) for a visual workflow builder with more power than Airtable's built-in scripts.

## Method 3: Custom Integration with Code

For developers who want full control, here's a Node.js integration:

### Basic Script

```javascript
const Airtable = require("airtable")
const fs = require("fs")

// Configure Airtable
const base = new Airtable({ apiKey: process.env.AIRTABLE_API_KEY }).base(
  process.env.AIRTABLE_BASE_ID
)

// Function to generate image - API returns image directly
async function generateProductCard(record) {
  const response = await fetch(
    `https://render.imejis.io/v1/${process.env.IMEJIS_TEMPLATE_ID}`,
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.IMEJIS_API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        product_name: record.get("Product Name"),
        price: `$${record.get("Price")}`,
        product_image: record.get("Product Image")?.[0]?.url,
      }),
    }
  )

  // Save image to file or upload to your CDN
  const imageBuffer = await response.arrayBuffer()
  const fileName = `product-${record.id}.png`
  fs.writeFileSync(`./images/${fileName}`, Buffer.from(imageBuffer))

  return `https://your-cdn.com/images/${fileName}`
}

// Process all records needing images
async function processNewProducts() {
  const records = await base("Products")
    .select({
      filterByFormula: '{Generated Card} = ""',
      maxRecords: 100,
    })
    .all()

  for (const record of records) {
    const imageUrl = await generateProductCard(record)

    await base("Products").update(record.id, {
      "Generated Card": imageUrl,
    })

    console.log(`Generated image for: ${record.get("Product Name")}`)
  }
}

processNewProducts()
```

### Python Version

```python
from airtable import Airtable
import requests
import os

# Initialize
airtable = Airtable(
    os.environ['AIRTABLE_BASE_ID'],
    'Products',
    api_key=os.environ['AIRTABLE_API_KEY']
)

def generate_product_card(record):
    fields = record['fields']

    # API returns image directly
    response = requests.post(
        f'https://render.imejis.io/v1/{os.environ["IMEJIS_TEMPLATE_ID"]}',
        headers={
            'Authorization': f'Bearer {os.environ["IMEJIS_API_KEY"]}',
            'Content-Type': 'application/json'
        },
        json={
            'product_name': fields.get('Product Name', ''),
            'price': f"${fields.get('Price', '')}",
            'product_image': fields.get('Product Image', [{}])[0].get('url')
        }
    )

    # Save image to file or upload to your CDN
    file_name = f"product-{record['id']}.png"
    with open(f'./images/{file_name}', 'wb') as f:
        f.write(response.content)

    return f"https://your-cdn.com/images/{file_name}"

def process_products():
    records = airtable.get_all(
        formula='{Generated Card} = ""',
        max_records=100
    )

    for record in records:
        image_url = generate_product_card(record)

        airtable.update(record['id'], {
            'Generated Card': image_url
        })

        print(f"Generated: {record['fields'].get('Product Name')}")

process_products()
```

### Running on a Schedule

Use cron (Linux), Task Scheduler (Windows), or a service like Railway or Render to run this script periodically:

```bash
# Run every hour
0 * * * * cd /path/to/script && node generate-images.js
```

Or set up a webhook endpoint that Airtable can call on record changes.

## Real-World Use Cases

### Product Catalog for E-commerce

**Airtable structure:**

- Product Name
- Price
- Sale Price (optional)
- Product Photo
- Category

**Generated images:**

- Product cards with price badges
- "Sale" overlays when Sale Price exists
- Category-colored borders

One template, hundreds of consistent product images. For a full walkthrough of e-commerce image workflows, see our [product image automation guide](/blogs/use-cases/ecommerce-product-image-automation).

### Team Directory

**Airtable structure:**

- Name
- Role
- Department
- Headshot
- LinkedIn URL

**Generated images:**

- Employee cards for website
- Speaker cards for events
- Social announcement graphics

New hires get their cards automatically when added to the database.

### Content Calendar

**Airtable structure:**

- Post Title
- Publish Date
- Category
- Author

**Generated images:**

- Social media preview cards
- Blog featured images
- Newsletter headers

Plan content in Airtable, images generate themselves.

## Tips for Better Results

### 1. Standardize Your Data

Inconsistent data creates inconsistent images. If some prices have "$" and others don't, your images will look messy.

**Fix:** Use Airtable formulas to standardize:

```text
CONCATENATE("$", Price)
```

### 2. Handle Missing Data

Not every record has every field. Your template should handle blanks gracefully.

**In your API call:**

```javascript
{
  product_name: record.get('Product Name') || 'Product',
  price: record.get('Price') ? `$${record.get('Price')}` : 'Contact for price'
}
```

### 3. Use Airtable Views for Filtering

Don't generate images for every record. Create views that filter to only records that need images:

- **Needs Image:** `{Generated Card} = ""`
- **Recent Updates:** `LAST_MODIFIED_TIME() > DATEADD(NOW(), -1, 'days')`

Point your automation at these views instead of the whole table.

### 4. Store Image URLs, Not Files

Airtable charges for attachment storage. Generated image URLs from Imejis.io are hosted on a CDN for free. Just store the URL.

## Cost Comparison

| Approach           | Monthly Cost (500 images) |
| ------------------ | ------------------------- |
| Designer (manual)  | $500-1000+                |
| Your time (manual) | 20+ hours                 |
| Imejis.io Basic    | $14.99                    |
| Imejis.io Pro      | $24.99 (for 10,000)       |

At $14.99/month, you're paying about 3 cents per product image. And they generate in seconds, not hours.

Check [our pricing page](/pricing) for current plans. _Pricing reflects published rates as of July 2026; check the provider's site for current plans._

## Getting Started

Here's the quick path:

1. **Organize your Airtable** with the fields you want in images
2. **Create a template** in [Imejis.io](https://www.imejis.io) matching those fields
3. **Connect with Zapier** (easiest) or build a script
4. **Test with a few records** before running on your whole database
5. **Set up automation** to handle new records automatically

Start with one use case. Product cards, team profiles, or social images. Get that working, then expand. If you're new to image APIs in general, our [how to generate images with an API](/blogs/tutorials/how-to-generate-images-with-api) tutorial covers the fundamentals. For large datasets, see [batch image generation from CSV](/blogs/tutorials/batch-image-generation-csv).

The goal isn't to replace designers. It's to stop doing repetitive design work that a database query could handle. Your Airtable data is already organized. Now make it visual. If your data lives in Google Sheets instead, check out our guide on [generating images from Google Sheets and uploading to Drive](/blogs/integrations/zapier/generate-images-google-sheets-with-imejis-and-upload-to-drive).

[Get started with Imejis.io for free](https://www.imejis.io)

## FAQ

### Can I use Airtable attachments as image sources?

Yes. Airtable attachments have URLs you can pass to the image API. Access the URL from the attachment field and use it as a dynamic image source in your template.

### What happens when I update a record in Airtable?

With Zapier, you can trigger on "New or Updated Record" to regenerate the image. With custom code, run the script on a schedule or set up webhooks to catch changes.

### How many images can I generate per day?

With Imejis.io's Pro plan ($24.99/month), you get 10,000 images per month. That's over 300 per day. The Unlimited plan goes up to 100,000/month for high-volume needs.

### Do I need coding skills for this?

No. The Zapier method requires zero code. Just point and click to connect your Airtable fields to the image template. Code is only needed if you want more control or custom logic.

### Can I generate different image sizes from the same data?

Yes. Create multiple templates in Imejis.io (one for Instagram square, one for Twitter landscape, etc.) and run separate generations for each. Same data, different outputs.