Airtable Image Generation: Turn Database Rows into 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. 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 wellWhy 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:

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

The architectureThe Architecture

Here's how the pieces connect:

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 (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 easiestMethod 1: Zapier Integration (Easiest)

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

Step 1 set up your airtable baseStep 1: Set Up Your Airtable Base

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

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

Step 2 create your template in imejisioStep 2: Create Your Template in Imejis.io

Design a template with editable fields matching your Airtable columns:

1. Go to 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 zapStep 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 activateStep 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 webhooksMethod 2: Airtable Automations + Webhooks

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

Set up the automationSet 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 scriptThe Script

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.

LimitationsLimitations

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.

Method 3 custom integration with codeMethod 3: Custom Integration with Code

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

Basic scriptBasic Script

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 versionPython Version

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 scheduleRunning on a Schedule

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

# 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 casesReal-World Use Cases

Product catalog for e commerceProduct 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.

Team directoryTeam 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 calendarContent 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 resultsTips for Better Results

1 standardize your data1. 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:

CONCATENATE("$", Price)

2 handle missing data2. Handle Missing Data

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

In your API call:

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

3 use airtable views for filtering3. 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 files4. 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 comparisonCost Comparison

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

Check our pricing page for current plans.

Getting startedGetting Started

Here's the quick path:

1. Organize your Airtable with the fields you want in images
2. Create a template in 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.

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.

Get started with Imejis.io for free

FaqFAQ

Can i use airtable attachments as image sourcesCan 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 airtableWhat 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 dayHow 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 thisDo 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 dataCan 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.