How to Run GPT Prompts Inside Airtable Automations

# Airtable GPT Automation: Auto-Generate SEO Meta + Executive Summary

## 1. Trigger Setup

Use **"When record matches conditions"**:
- **Table:** Posts
- **Condition:** `Status` is `Ready for Review`

This fires only on the status transition, avoiding accidental runs on unrelated edits.

## 2. Required Fields in `Posts`

| Field | Type | Notes |
|---|---|---|
| Title | Single line text | Existing |
| Draft | Long text | Existing |
| Status | Single select | Existing; include "Ready for Review" |
| Meta Description | Long text | New — GPT output |
| Executive Summary | Long text | New — GPT output (3 bullets) |
| GPT Error | Long text | New — captures failures for debugging |

## 3. Run Script Action

In the automation, add a **"Run script"** action. Configure **Input variables**:
- `recordId` → Airtable record ID (from trigger)
- `title` → Title (from trigger)
- `draft` → Draft (from trigger)
- `openaiKey` → your API key (hardcode here or store in a config table and pull it in)

Paste this script:

```javascript
const { recordId, title, draft, openaiKey } = input.config();
const table = base.getTable("Posts");

const systemPrompt = `You are an expert SEO editor and content strategist. 
You return ONLY valid JSON matching this exact schema:
{"meta_description": "string (<=155 chars, compelling, includes primary keyword)", 
 "executive_summary": ["bullet 1", "bullet 2", "bullet 3"]}
No preamble, no markdown fences.`;

const userPrompt = `Title: ${title}

Draft:
${draft}

Generate:
1. An SEO meta description under 155 characters.
2. A 3-bullet executive summary (each bullet <=20 words, action-oriented).`;

try {
    const res = await fetch("https://api.openai.com/v1/chat/completions", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "Authorization": `Bearer ${openaiKey}`
        },
        body: JSON.stringify({
            model: "gpt-4o",
            temperature: 0.4,
            response_format: { type: "json_object" },
            messages: [
                { role: "system", content: systemPrompt },
                { role: "user", content: userPrompt }
            ]
        })
    });

    if (!res.ok) {
        const errText = await res.text();
        throw new Error(`OpenAI ${res.status}: ${errText}`);
    }

    const data = await res.json();
    const content = data.choices[0].message.content;
    const parsed = JSON.parse(content);

    const bullets = parsed.executive_summary
        .map(b => `• ${b}`)
        .join("\n");

    await table.updateRecordAsync(recordId, {
        "Meta Description": parsed.meta_description,
        "Executive Summary": bullets,
        "GPT Error": ""
    });

} catch (err) {
    await table.updateRecordAsync(recordId, {
        "GPT Error": `${new Date().toISOString()} — ${err.message}`
    });
    throw err; // surface failure in automation run history
}
```

## 4. Prompt Strategy (embedded above)

- **System message** locks output to strict JSON — critical since Airtable scripts cannot retry parsing loops gracefully.
- **`response_format: json_object`** forces OpenAI to return valid JSON, eliminating markdown fence stripping.
- **User message** passes dynamic record data and explicit constraints (char limits, bullet count).

## 5. Testing & Error-Handling Tips

1. **Test with a real record:** In the automation editor, click the trigger step → "Choose record" → pick a Post with real Draft content so input variables populate during script testing.
2. **Run the script step in isolation** using the "Test" button before enabling the automation. Check the console for the raw OpenAI response.
3. **Watch for truncated drafts:** Airtable input variables have a ~100KB limit, but very long drafts may hit OpenAI token limits. Add `draft.slice(0, 12000)` if you deal with long-form content.
4. **The `GPT Error` field** lets non-technical teammates see failures without opening automation run history.
5. **Rate limits / transient 429s:** Wrap the fetch in a retry helper if volume grows:
   ```javascript
   for (let i = 0; i < 3; i++) {
     const r = await fetch(...);
     if (r.status !== 429) return r;
     await new Promise(res => setTimeout(res, 1000 * (i + 1)));
   }
   ```
6. **Avoid infinite loops:** Since writing to the record doesn't change Status, the trigger won't re-fire. Confirm by keeping the trigger condition scoped to `Status = Ready for Review` only.
7. **Cost control:** Log usage by adding `data.usage.total_tokens` to a separate "Token Log" table if you scale this across many posts.

# Airtable GPT-4 Automation: SEO Meta & Executive Summary Generator

## 1. Trigger Setup

**Automation Name:** Generate SEO Meta & Summary on Review

**Trigger Type:** When a record matches a condition
- **Table:** Posts
- **Condition:** `Status` is exactly `Ready for Review`
- **Trigger:** Runs once per matching update

This ensures the automation fires only when Status changes to "Ready for Review", avoiding redundant API calls.

---

## 2. Required Fields in 'Posts' Table

| Field Name | Field Type | Notes |
|---|---|---|
| Title | Single line text | Existing |
| Draft | Long text | Existing |
| Status | Single select | Existing; options include "Ready for Review" |
| SEO Meta Description | Long text | **New** – stores GPT output |
| Executive Summary | Long text | **New** – stores GPT output (3 bullets) |

Both output fields should allow rich text or plain text (long text type handles both). Do not set them as formulas or rollups—they need to be writable via the script.

---

## 3. Run Script Action Configuration

In your Automation, add a **Run script** action after the trigger.

**Input Variables to Configure:**
- `OPENAI_API_KEY` – reference your stored secret (Airtable → Automations → Secrets)
- `recordId` – automatically populated from trigger
- `title` – map from `{Posts.Title}`
- `draft` – map from `{Posts.Draft}`

**Script Code:**

```javascript
// Input variables provided by Airtable automation
const { OPENAI_API_KEY, recordId, title, draft } = input.config();

const baseId = 'appXXXXXXXXXXXXXX'; // Replace with your base ID
const tableId = 'tblXXXXXXXXXXXXXX'; // Replace with your Posts table ID
const apiToken = 'patXXXXXXXXXXXXXX'; // Replace with your Airtable PAT

// OpenAI API call
async function generateContent(postTitle, postDraft) {
  const systemPrompt = `You are an expert SEO copywriter and content strategist. Your task is to:
1. Create a compelling SEO meta description (max 160 characters) that includes the primary keyword and encourages clicks.
2. Write a 3-bullet executive summary of the post content, each bullet 1–2 sentences, highlighting key takeaways.

Return ONLY valid JSON with no markdown, no extra text. Format:
{
  "metaDescription": "...",
  "executiveSummary": "• Bullet 1\n• Bullet 2\n• Bullet 3"
}`;

  const userPrompt = `Post Title: "${postTitle}"

Post Draft:
${postDraft}`;

  try {
    const response = await fetch('https://api.openai.com/v1/chat/completions', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${OPENAI_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: 'gpt-4',
        messages: [
          { role: 'system', content: systemPrompt },
          { role: 'user', content: userPrompt },
        ],
        temperature: 0.7,
        max_tokens: 500,
      }),
    });

    if (!response.ok) {
      throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
    }

    const data = await response.json();
    const content = data.choices[0].message.content.trim();
    
    // Parse JSON response
    const parsed = JSON.parse(content);
    return {
      metaDescription: parsed.metaDescription,
      executiveSummary: parsed.executiveSummary,
    };
  } catch (error) {
    console.error('Error calling OpenAI:', error.message);
    throw error;
  }
}

// Update Airtable record
async function updateRecord(recordId, metaDescription, executiveSummary) {
  const url = `https://api.airtable.com/v0/${baseId}/${tableId}/${recordId}`;

  const response = await fetch(url, {
    method: 'PATCH',
    headers: {
      'Authorization': `Bearer ${apiToken}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      fields: {
        'SEO Meta Description': metaDescription,
        'Executive Summary': executiveSummary,
      },
    }),
  });

  if (!response.ok) {
    throw new Error(`Airtable update failed: ${response.status} ${response.statusText}`);
  }

  return response.json();
}

// Main execution
(async () => {
  try {
    const content = await generateContent(title, draft);
    await updateRecord(recordId, content.metaDescription, content.executiveSummary);
    console.log('✓ Record updated successfully');
  } catch (error) {
    console.error('Automation failed:', error.message);
    throw error;
  }
})();
```

---

## 4. GPT Prompt (Embedded in Script)

**System Message:**
```
You are an expert SEO copywriter and content strategist. Your task is to:
1. Create a compelling SEO meta description (max 160 characters) that includes the primary keyword and encourages clicks.
2. Write a 3-bullet executive summary of the post content, each bullet 1–2 sentences, highlighting key takeaways.

Return ONLY valid JSON with no markdown, no extra text.
```

**User Message:**
```
Post Title: "{postTitle}"

Post Draft:
{postDraft}
```

**Response Format (JSON):**
```json
{
  "metaDescription": "Your 160-char meta description here",
  "executiveSummary": "• Bullet 1\n• Bullet 2\n• Bullet 3"
}
```

The JSON-first prompt prevents GPT from adding markdown fences or extra commentary.

---

## 5. Testing & Error Handling Tips

1. **Replace IDs Before Running:**
   - Find `baseId` and `tableId` in your Airtable URL: `https://airtable.com/bases/{baseId}/{tableId}`
   - Generate a Personal Access Token (PAT) at airtable.com/account/tokens with `data.records:write` scope

2. **Test Dry Run:**
   - Manually change a test record's Status to "Ready for Review"
   - Check Automation logs (Automations tab → History) for script output

3. **Common Issues:**
   - **API Key missing:** Verify the secret is stored in Automations → Secrets, not hardcoded
   - **Invalid JSON from GPT:** Add retry logic or use `temperature: 0.5` for consistency
   - **Field name mismatch:** Ensure field names in the script exactly match Airtable (case-sensitive)

4. **Add Fallback Fields:**
   - Create a `Generation Status` field (single select: Success/Failed) to track runs
   - Log errors to an `Error Log` field for debugging

5. **Rate Limiting:**
   - Airtable scripts timeout after 30 seconds; OpenAI usually responds in 2–5 seconds
   - If batching posts, add 1-second delays between API calls

This workflow is production-ready and handles async/await patterns within Airtable's scripting sandbox.

Of course. Here is a complete, production-ready Airtable GPT automation workflow to generate a meta description and executive summary for your blog posts.

### 1. Automation Trigger Setup

The automation should trigger only when a post is explicitly marked as ready for review. This prevents it from running on every minor edit.

*   **Trigger type:** `When record matches conditions`
*   **Table:** `Posts`
*   **Conditions:** `Where [Status] is [Ready for Review]`

This setup ensures the script runs once at the correct stage in your pipeline.

### 2. Airtable Fields Required

Ensure your `Posts` table has the following fields. The last two are new fields you will need to add for the GPT-4 output.

*   `Title` (Single line text) - Input
*   `Draft` (Long text) - Input

### 1. Required Fields
Add to 'Posts' table:
- **Meta Description** (Long text)
- **Executive Summary** (Long text)

Existing: Title (Single line text), Draft (Long text), Status (Single select: include "Ready for Review").

### 2. Automation Trigger Setup
- **Trigger**: When record updated (Posts table).
- **Condition** (Only continue if): `{Status} = "Ready for Review"` **AND** `{Meta Description} is empty`.
- **Action**: Run script.
  - Input variables:
    | Variable       | Type | Source          |
    |----------------|------|-----------------|
    | `recordId`     | Text | Record ID       |
    | `openAiApiKey` | Text | (Paste your key)|

### 3. Run Script Action Code
```javascript
let inputConfig = input.config();
let recordId = inputConfig.recordId;
let apiKey = inputConfig.openAiApiKey;

let table = base.getTable("Posts");
let record = await table.selectRecordAsync(recordId, {fields: ["Title", "Draft"]});
if (!record) {
  output.text("Record not found");
  return;
}

let title = record.getCellValue("Title") || "";
let draft = record.getCellValue("Draft") || "";

let systemPrompt = `You are an expert SEO copywriter for blog posts. Generate concise, compelling outputs.`;

let userPrompt = `Title: ${title}\n\nDraft: ${draft}\n\nOutput ONLY valid JSON: {"metaDescription": "150-160 char SEO meta desc with keywords", "executiveSummary": "- Bullet 1\n- Bullet 2\n- Bullet 3"}`;

let response = await fetch("https://api.openai.com/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "gpt-4o-mini",
    messages: [
      {"role": "system", "content": systemPrompt},
      {"role": "user", "content": userPrompt}
    ],
    temperature: 0.3,
    max_tokens: 300
  })
});

let data = await response.json();
if (!response.ok) {
  output.text(`API Error: ${data.error?.message}`);
  return;
}

let content = data.choices[0].message.content;
let result;
try {
  result = JSON.parse(content);
} catch (e) {
  output.text(`Parse Error: ${content}`);
  return;
}

await table.updateRecordAsync(recordId, {
  "Meta Description": result.metaDescription,
  "Executive Summary": result.executiveSummary
});

output.text("Fields updated successfully");
```

### 4. GPT Prompt
Embedded in script (Section 3): System + User messages generate JSON for reliable parsing.

### 5. Testing & Error-Handling Tips
- **Test**: Use Scripting app: `let table = base.getTable('Posts'); await table.updateRecordAsync('recXXX', {Status: 'Ready for Review'});` then manually run automation.
- **Debug**: Check "Runs" tab for logs. Add `output.text()` for vars (e.g., title). Handle rate limits with `try-catch` on fetch.
- **Errors**: Invalid key → 401 (check input var). Empty fields → skip via condition. Loops prevented by condition. Monitor token usage (~200/record).

(298 words)