Airtable to AI Presentation Workflow Guide (2026)

Airtable is the source-of-truth database for thousands of teams — CRM pipelines, project trackers, content calendars, investor CRMs, inventory systems. The 2026 Airtable-to-deck pipeline turns any Airtable view into a finished PowerPoint deck in under a minute using two approaches: (1) no-code via Airtable Automations + Make/Zapier + 2Slides API, ideal for per-record or per-view decks (weekly client reviews, monthly investor updates); (2) custom Airtable Extension using the 2Slides V1 API, ideal for on-demand deck generation from inside Airtable itself. This guide walks through both workflows with working code, the exact 2Slides API payload, and four real Airtable-driven deck patterns (sales pipeline review, content-calendar monthly report, project-tracker QBR, investor-CRM update) that you can adapt to your own base. Every pattern ships with the exact field mappings, prompt construction logic, and polling strategy so you can paste it into your own workspace and have a production-ready integration by the end of the afternoon.

---

The 2026 Airtable-to-Deck Architecture

Most Airtable bases already contain 80% of a deck: the numbers, the names, the dates, the status flags. What's missing is the narrative layer — the headline, the framing, the "what this means for the business." That's precisely the gap a large-language-model deck generator fills.

The 2026 architecture separates three concerns:

1. Data layer (Airtable) — records, views, filters, roll-ups. This is where your source of truth lives. Nothing about the deck generation workflow should require duplicating data elsewhere.
2. Orchestration layer (Airtable Automations, Zapier, Make, or a custom Extension) — the glue that listens for triggers (a button press, a status change, a scheduled cron), queries the relevant records, formats them into a prompt, and calls the 2Slides API.
3. Generation layer (2Slides V1 API) — the
   /api/v1/slides/generate
   endpoint accepts a prompt plus optional theme and page-count parameters, then asynchronously produces a PowerPoint file with AI-generated narrative, structured charts, speaker notes, and optional narration audio.

The orchestration layer is where implementation choice matters. Teams that want zero code reach for Airtable Automations + Zapier webhooks. Teams that want a "Generate Deck" button inside Airtable itself build a custom Extension. Both paths converge on the same API contract, so you can prototype with the no-code path and harden into the Extension path later.

Method 1: No-Code (Airtable Automations + Zapier + 2Slides)

The no-code path is the fastest to production — typically under an hour — and is the right choice when the trigger is record-based (a new deal enters stage "Proposal," a project is marked "Ready for QBR," a campaign hits end-of-month).

Step 1: Prepare the Airtable base

Add three fields to the table you want to generate decks from:

• Deck Status
  (single select: Queued, Generating, Ready, Failed)
• Deck URL
  (URL)
• Deck Job ID
  (single line text)

These fields let the automation write progress back to the record so the user sees the deck appear in the same row they triggered it from.

Step 2: Build the Airtable Automation

Create a new automation with trigger "When record matches conditions" — e.g., Deck Status is Queued. Add a "Run a script" action that formats the record into a prompt:

const inputConfig = input.config();
const record = inputConfig.record;

const prompt = `Create a 10-slide account review deck for ${record.accountName}.
Pipeline value: $${record.pipelineValue.toLocaleString()}.
Current stage: ${record.stage}.
Last touchpoint: ${record.lastTouchpoint}.
Open risks: ${record.risks}.
Recommended next action: ${record.nextAction}.

Structure: title, executive summary, relationship history, pipeline status,
risks and blockers, opportunity sizing, recommended next steps, appendix.`;

output.set('prompt', prompt);
output.set('recordId', record.id);

Step 3: Send the webhook to Zapier (or Make)

Add a "Send webhook" action that POSTs to a Zapier catch hook. Zapier's second step calls the 2Slides API:

POST https://2slides.com/api/v1/slides/generate
Headers:
  Authorization: Bearer {{YOUR_2SLIDES_API_KEY}}
  Content-Type: application/json
Body:
{
  "prompt": "{{prompt from Airtable}}",
  "pages": 10,
  "theme": "corporate-navy",
  "language": "en",
  "webhook": "https://hooks.zapier.com/hooks/catch/XXXXX/airtable-deck-ready"
}

The response includes a

. Store it back in the Airtable record via Zapier's Airtable action, and set to Generating.

Step 4: Handle the completion webhook

2Slides calls your webhook URL once the job finishes. That Zap reads the

and patches the Airtable record with and . Total end-to-end latency: typically 40-75 seconds.

If you don't want to use webhooks, poll

every 5 seconds from a second Zap triggered on a schedule. For a deeper look at polling patterns and retry logic, see our companion guide on automating presentation generation with Python and the 2Slides API.

Method 2: Custom Airtable Extension

When you want a "Generate Deck" button embedded directly in the Airtable UI — no external Zap, no webhook routing — a custom Extension is the right shape. Airtable Extensions are React applications that render inside the base and can call external APIs using

.

Here is a minimal Extension that reads the selected record, calls

, and polls until the deck is ready:

import {
  initializeBlock, useBase, useCursor, useRecordById,
  Button, Text, Box, useGlobalConfig,
} from '@airtable/blocks/ui';
import React, { useState } from 'react';

function DeckGenerator() {
  const base = useBase();
  const cursor = useCursor();
  const globalConfig = useGlobalConfig();
  const apiKey = globalConfig.get('TWO_SLIDES_API_KEY');

  const table = base.getTableByIdIfExists(cursor.activeTableId);
  const record = useRecordById(table, cursor.selectedRecordIds[0] || '');

  const [status, setStatus] = useState('idle');
  const [deckUrl, setDeckUrl] = useState(null);

  async function generateDeck() {
    if (!record) return;
    setStatus('submitting');

    const prompt = buildPrompt(record);
    const res = await fetch('https://2slides.com/api/v1/slides/generate', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ prompt, pages: 10, theme: 'corporate-navy' }),
    });

    const { jobId } = await res.json();
    setStatus('generating');
    pollJob(jobId);
  }

  async function pollJob(jobId) {
    const interval = setInterval(async () => {
      const res = await fetch(`https://2slides.com/api/v1/jobs/${jobId}`, {
        headers: { 'Authorization': `Bearer ${apiKey}` },
      });
      const job = await res.json();
      if (job.status === 'success') {
        clearInterval(interval);
        setDeckUrl(job.downloadUrl);
        setStatus('ready');
        await table.updateRecordAsync(record, {
          'Deck URL': { url: job.downloadUrl },
          'Deck Status': { name: 'Ready' },
        });
      } else if (job.status === 'failed') {
        clearInterval(interval);
        setStatus('failed');
      }
    }, 5000);
  }

  return (
    <Box padding={3}>
      <Button onClick={generateDeck} disabled={status === 'generating'}>
        {status === 'generating' ? 'Generating…' : 'Generate Deck'}
      </Button>
      {deckUrl && <Text>Deck ready: <a href={deckUrl}>Download</a></Text>}
    </Box>
  );
}

function buildPrompt(record) {
  return `Create a 10-slide deck for ${record.getCellValueAsString('Account')}.
    Pipeline: ${record.getCellValueAsString('Pipeline Value')}.
    Stage: ${record.getCellValueAsString('Stage')}.
    Notes: ${record.getCellValueAsString('Notes')}.`;
}

initializeBlock(() => <DeckGenerator />);

This gives you a one-click "Generate Deck" button inside any Airtable view. The Extension pattern also makes it easy to reuse a single API key across your whole team via

. For the broader product-engineering view on embedding AI deck generation into any SaaS interface, see integrating AI slide generation into a SaaS product.

The 2Slides API Payload for Airtable Data

The

endpoint accepts the following JSON structure. Everything except is optional, but Airtable-driven workflows benefit from explicitly setting , , and for consistent output.

{
  "prompt": "Create a 12-slide Q4 pipeline review for Acme Corp. Pipeline value: $420,000 across 7 open deals. Top account: Globex ($180,000, Proposal stage). At-risk: Initech ($60,000, stalled 28 days). Structure: title, executive summary, pipeline overview chart, account-by-account, risks, forecast, recommended next actions, appendix.",
  "pages": 12,
  "theme": "corporate-navy",
  "language": "en",
  "aspectRatio": "16:9",
  "tone": "executive",
  "includeSpeakerNotes": true,
  "webhook": "https://your-app.com/webhooks/deck-ready"
}

Response:

{ "jobId": "tl_a1b2c3d4e5", "status": "pending" }

To check progress without webhooks, poll

. A response returns (the ), (if PDF was requested), and (array of per-page metadata including image and voice URLs).

Related V1 endpoints worth knowing for Airtable workflows:

• POST /api/v1/slides/generate
  — primary prompt-to-deck endpoint.
• POST /api/v1/slides/create-pdf-slides
  — accepts a source PDF (e.g., an uploaded Airtable attachment) and produces a deck summarizing it.
• POST /api/v1/slides/create-like-this
  — clones structure from an existing deck; useful when you want every weekly client review to match a template.
• POST /api/v1/slides/generate-narration
  — generates voiceover audio for each slide. Pair with the video export pipeline for Loom-style async updates.
• GET /api/v1/slides/download-slides-pages-voices/:jobId
  — bulk-fetches all per-page images and voice files as a ZIP, handy for Airtable attachments fields.
• GET /api/v1/jobs/:id
  — polling endpoint for job status.
• GET /api/v1/themes/search?q=corporate
  — searchable theme directory, so you can let Airtable users pick a theme via a linked-record field.

4 Real Airtable-Driven Deck Patterns

Pattern 1: Sales Pipeline Review

Base structure: table of

with fields for , , , , , , .

Trigger: Friday 8:00 AM schedule, filtered to deals where

is Proposal or Negotiation.

Prompt construction: aggregate all matching records into a single prompt with totals by stage, a top-5 list by ARR, and a flagged list for deals untouched in 14+ days. Set

, , .

Outcome: every Monday morning the sales leader opens Airtable and has a deck titled "Pipeline Review — Week of {date}" already attached to a synced "Weekly Reviews" table. No manual slide copy-paste.

Pattern 2: Content Calendar Monthly Report

Base structure:

table with , , , , , .

Trigger: first of each month, automation runs against records from the previous 30 days.

Prompt construction: rank by engagement, compute month-over-month delta, group by channel. Ask the model for a 10-slide deck structured as: recap, top performers, underperformers, channel mix, author leaderboard, recommendations. Set

, , .

Outcome: content leads get a deck they can take into the monthly review meeting without touching PowerPoint.

Pattern 3: Project Tracker QBR

Base structure:

table with , , , , , , .

Trigger: manual button in Airtable Extension, scoped to one client at a time.

Prompt construction: pull every project for the client from the last quarter, summarize by completion status, surface any blockers, compute hours utilization. Structure the deck as: title, quarter at a glance, project-by-project recap, blockers + risks, forecast for next quarter, recommended scope adjustments. Set

, .

Outcome: the PM opens the client's record, hits "Generate QBR Deck," and has a 14-slide deliverable in under a minute. They review, edit in PowerPoint if needed, and send.

Pattern 4: Investor CRM Update

Base structure:

table with , , , , .

Trigger: fired when

changes to Scheduled Follow-Up.

Prompt construction: build a company-update deck tailored to that investor's stated stage interest. Pull company metrics from a linked

table — MRR, growth rate, burn, runway, headcount — and inject them into the prompt. Structure: title, what's changed since last conversation, KPI update, new logos, product roadmap, team, the ask. Set , , and use pointing to a prior deck so every investor update has a consistent visual identity.

Outcome: every investor follow-up gets a personalized, on-brand deck without the founder rebuilding from a master template.

Frequently Asked Questions

How do I pass Airtable attachments (PDFs, decks) into the 2Slides API?

Airtable exposes attachments as URLs in the record payload. For PDF inputs, call

with the attachment URL as the field. For an existing PowerPoint you want to style-match, download the attachment first, then call with the file upload. Both endpoints return a that you poll the same way as .

Can I use Airtable roll-ups and formula fields in the prompt?

Yes, and you should. Roll-ups (total ARR, average deal size, count of at-risk projects) produce exactly the kind of summary numbers that make decks useful. Reference them the same way as any other field in your Automation script —

— and embed them into the prompt string.

What happens if the 2Slides job fails?

Failed jobs return

from with an field describing the cause (most commonly: malformed prompt, unsupported theme slug, insufficient credits). In production Airtable workflows, catch this in the polling step, set on the record, and optionally retry with a simpler prompt. Budget one retry per record; persistent failures usually indicate a prompt-construction bug worth logging.

How do I keep my 2Slides API key out of Airtable scripts?

For Automations scripts, store the key in a single-record config table and read it dynamically, or pass it as an input variable that references an environment secret in Zapier/Make. For Extensions, use

via a one-time admin setup screen — this stores the key in the base's metadata, not in source-controlled code.

Can multiple team members share one API key without hitting rate limits?

Yes. 2Slides rate limits are generous for Team plan keys (typically 60 requests/minute, 500/hour), which comfortably supports 10-20 active Airtable users triggering decks. For higher-volume programmatic workflows — say, generating a deck per customer nightly across 2,000 customers — split into batches and stagger the calls, or request an Enterprise key with higher limits.

The Takeaway

Airtable is brilliant at storing structured, relational, team-shared data. PowerPoint is brilliant at delivering narrative to humans. The gap between them — the "now turn this into a deck" gap — used to burn hours every week for sales leaders, content marketers, PMs, and founders. In 2026, that gap closes with a single webhook or a single button.

The two methods in this guide cover the full spectrum: the no-code path gets you to production in an afternoon with zero infrastructure, and the Extension path gives your team a native-feeling "Generate Deck" button that lives inside Airtable itself. Both converge on the same

contract, which means you can start with Zapier, validate the prompt structure against real records, and graduate to a custom Extension once the workflow is proven. The four patterns above — pipeline review, content report, project QBR, investor update — cover the majority of real Airtable-driven deck use cases, and they're deliberately small enough to paste into your own base and adapt in an afternoon.

Turn any Airtable view into a PowerPoint — get a 2Slides API key and wire it into your Airtable automations in under an hour.