---
title: "Video sales letter scripts from Airtable"
kind: "Kit"
category: "Marketing & SEO"
price: "Free"
seller: "Mindket"
version: "2"
url: "https://mindket.com/p/fb0fd54a-eb0e-4ce1-9b21-6ca28e9f14f9"
updated: "2026-11-09"
---

# Video sales letter scripts from Airtable

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow that runs a video sales letter desk from Airtable. Perplexity researches the product, Gemini writes ad angles and full scripts, and a weekly job logs your Facebook video ad results and transcribes the winning ads.

Video sales letter scripts from Airtable is an n8n workflow in the Marketing \& SEO category, listed by Mindket. It is free. This is version 2, last updated on 2026-11-09. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow turns an Airtable base into a small studio for video sales letters. Its 54 nodes make up three flows, and they are independent, so you can use one and ignore the others. The first answers calls to a webhook and does four jobs. Perplexity researches a product and its buyers. Gemini proposes five to eight ad angles, writes a full script for the angle you pick and rewrites that script from your notes. Each result goes back into the Airtable record it came from. The second flow runs weekly and logs your active Facebook video ads with their spend, clicks and conversions. The third takes one logged ad, fetches its video through Scrapfly and has OpenAI transcribe it, so your best ads can shape the next round of angles.

A webhook call names an action and a record → Perplexity researches the product and its buyers → Gemini writes the angles as Airtable rows → Gemini scripts the angle you pick, then revises it → A weekly job logs ads, and winners get transcribed

### Who it suits

Performance marketers, small agencies and in-house ad teams that write video ads for Facebook and want the research, the angle ideas and the first drafts in one Airtable base. It is a build for people who already work in Airtable.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Online retail | Brand owners and media buyers | Log each product in the Product table, then call the research action and the angles action | A buyer adds a new water bottle and finds a buyer profile and a set of angles in the base, with no brief written. |
| Marketing agencies | Creative strategists | Keep one base per client and link each client’s best ad transcripts to the product through the Winning Ad Script field | A strategist transcribes a client’s top video ad, then asks for fresh angles that build on what it did. |
| Courses and coaching | Course creators | Research who buys a program, then script each angle as a short ad | A creator researches the buyers of a language course and scripts three angles to test against each other. |
| Software and apps | In-house growth teams | Type notes into a script’s feedback field and call the revision action | A growth lead asks for a shorter, calmer version, and the script is rewritten in place. |

Skip it if you do not use Airtable or run Facebook video ads. Both are built in, and the script prompt is written for Facebook ad video.

### Where to use it

Any n8n that your Airtable can reach over the internet, because Airtable makes the calls.

- n8n Cloud or your own server: import the file and publish it, so the production addresses of both webhooks work
- Airtable: button fields or automations with a script step make the calls, and each result lands in the record it came from
- Facebook ads: the weekly job reads the ad accounts that your access token can see
- Your video team: the scripts sit in Airtable for the people who film and edit them

### How to set it up

Get it saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. The file holds no credential, and the Airtable base is not in it, so build the base first.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server with an address Airtable can reach |
| Airtable | A base with Product, Scripting and Ads Performance tables, and a personal access token that can read and write it |
| Perplexity | An API key, kept in n8n as an HTTP Header Auth credential |
| Google AI Studio | A key for the Gemini API |
| OpenAI | An API key, for parsing the angles and for transcripts |
| Facebook | A Marketing API access token that can read ads, for the weekly job |
| Scrapfly | An API key, only for the transcript flow |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Build the Airtable base from the tables in the setup notes, add an Airtable credential and select it in every Airtable node.
3. In those nodes, put your base in `YOUR_BASE_ID` and each table in `YOUR_PRODUCT_TABLE_ID`, `YOUR_SCRIPTING_TABLE_ID` or `YOUR_ADS_TABLE_ID`.
4. Add an HTTP Header Auth credential with the header `Authorization` and your Perplexity key, and select it in `Product Overview & Customer Research`.
5. Add Google Gemini and OpenAI credentials and select them in the chat model and OpenAI nodes.
6. Add a Facebook Graph API credential with your token and select it in the Facebook nodes.
7. In `HTTP Request1`, put your Scrapfly key where it says `YOUR_SCRAPFLY_KEY`.
8. Save, press Publish, copy the production addresses of `Webhook` and `Webhook1`, and point your Airtable buttons or automations at them.

### How to use it

Call the `ai-vsl` address with two values in its query string: `action`, and `recordId`, the Airtable record to work on. The action decides which table the record belongs to.

The four actions

| Action | Record from | What happens | Written back |
| --- | --- | --- | --- |
| generateProjectDetails | Product | Perplexity writes a profile of the product and its buyers from Product Name and Product Notes | Product Details, and Status |
| generateAngles | Product | Gemini proposes five to eight angles from the profile, the notes, the winning scripts and the angles you already have | One Scripting row per angle |
| generateScript | Scripting | Gemini writes the full script for that angle | Script, and Status |
| feedbackIteration | Scripting | Gemini rewrites the script from your notes | Script, and Status |

The second address, `ad-scraping`, takes the `recordId` of an Ads Performance row and transcribes that ad’s video into its Video Script field. The weekly job needs no call: it starts from its own schedule.

### Example

A shop adds a water bottle to the Product table with a few notes. The first action returns a profile of the product and who buys it. The second adds Scripting rows, one per angle, with these fields filled:

```json
{
  "AngleHeadline": "…",
  "ConceptSummary": "…",
  "VSLStructure": "…",
  "VideoSuggestion": "…",
  "EmotionalTriggers": "…",
  "CognitiveBiasesLeveraged": "…",
  "DirectResponseTechniques": "…"
}
```

A call is a plain GET, with your own address and record ID:

```text
GET https://YOUR-N8N-ADDRESS/webhook/ai-vsl?action=generateAngles&recordId=YOUR_RECORD_ID
```

Calling `generateScript` on one of those rows fills Script with Markdown that opens straight on the hook, with no introduction, and runs through Hook, Lead, Body and CTA. Put notes in the feedback field and call `feedbackIteration` to get a rewrite.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. This file is large, but three notes name its groups: `Weekly Ad Schedule`, `Best Ad Video Transcript` and `Scripting/Idea Generation/Feedback System`. Set up the last group first and get research, angles and scripts working before you touch Facebook.

**For experts.** Five models and services share the work, and each step names its own.

The model behind each step

| Step | Model | What to know |
| --- | --- | --- |
| Research | Perplexity sonar-reasoning, through an HTTP Request node | The request text lives in \`Edit Fields2\`, and a header-auth credential carries the key |
| Angles | Gemini, models/gemini-2.5-pro-exp-03-25 | An experimental model id. If the node reports that it is gone, pick a current Gemini Pro model |
| Parsing the angles | OpenAI gpt-4o-mini with a Structured Output Parser | The schema requires seven fields per angle and allows no others |
| Scripts and revisions | The same Gemini model | The script prompt fixes the four-part layout. The revision prompt is short, so your notes carry the change |
| Transcripts | OpenAI audio transcription | The file sets no model, so the node uses its default |

### Good to know

Every part bills its own provider, and two parts are fragile.

- Open webhooks: anyone who learns an address can start runs on your keys, so add authentication to both webhook nodes or keep the addresses private
- Overwrites: a revision replaces Script, so copy the old text first if you want to keep it
- Field names: the script prompts read \`Time\` and \`Feedback\`, while the file’s own Scripting schema names those fields \`3️⃣ Select Script Length\` and \`4️⃣ Feedback\`. Make the names and the expressions agree
- Weekly rows: \`Airtable9\` creates a row for every active video ad each week and never updates an old one, so the table fills with repeats
- Conversions: \`Edit Fields6\` reads them from \`actions\[4\]\` and \`action\_values\[8\]\`, positions that suit one account’s data. Check them against yours
- Wait: the \`Wait\` node holds 30 with no unit, and n8n’s default unit is seconds, so it pauses 30 seconds. Set minutes there if you meant them
- Transcripts: the video address is found by searching a Facebook page that Scrapfly fetched, so a change to that page breaks this branch. Check Facebook’s and Scrapfly’s terms for your use
- Your data: product notes and scripts reach Perplexity, Google and OpenAI, and ad videos reach Scrapfly and OpenAI

## README

```markdown
# Video sales letter scripts from Airtable

An n8n workflow. Call its webhook with a record from your Airtable base, and it researches a product, proposes ad angles,
writes a video sales letter script for the angle you pick and rewrites it from your notes. A weekly job also logs your
active Facebook video ads, and a second webhook transcribes the video of a logged ad.

## What is inside

- `workflow.json`: the workflow as n8n exports it, 54 nodes in three groups. It holds no credential, none of its author's
  Airtable ids and no stored run data. Its groups carry the labels `Weekly Ad Schedule`, `Best Ad Video Transcript` and
  `Scripting/Idea Generation/Feedback System`.
- `README.md`: these notes.
- Not included: the Airtable base. Build it from the table list below.

One repair: the original copy of the file had lost three backslashes. Mindket put them back in `Code1` (the pattern that finds
the video address, and its `&` clean-up) and in the line join of `Generate Angles`.

## Before you start

- An n8n instance with an address Airtable can reach: n8n Cloud, or your own server on the internet.
- An Airtable base with the three tables below, and a personal access token that can read and write it.
- A Perplexity API key.
- A Gemini API key from Google AI Studio.
- An OpenAI API key.
- For the weekly job: a Facebook Marketing API access token that can read ads.
- For transcripts: a Scrapfly API key.

## The Airtable base

The nodes read and write these fields. Names are as the file writes them, emoji included.

| Table | Fields the workflow uses |
|---|---|
| Product | `Product Name`, `Product Notes`, `Product Details`, `Status`, `2️⃣ Generate Angles`, `Winning Ad Script`, `Angle Headline`, and a link to Scripting |
| Scripting | `AngleHeadline`, `ConceptSummary`, `VSLStructure`, `VideoSuggestion`, `EmotionalTriggers`, `CognitiveBiasesLeveraged`, `Direct Response Techniques`, `Script`, `Status`, `5️⃣ Generate Script`, `About Product`, a link to Product, and the length and feedback fields |
| Ads Performance | `Ad Name`, `Ad ID`, `Video ID`, `Campaign Name`, `AdSet Name`, `Active Status`, `Spend`, `Impressions`, `Clicks`, `CPC`, `CPM`, `Conversions`, `Conversion Value`, `Best Ads?`, `Video Script` |

`Status` on Product takes Idle, Generating Product Details, Generating Angles, Product Details Generated and Angles Generated.
On Scripting it takes Idle, Generating Script, Revision in progress, Script Generated and Script Revised.

In the file's schema, `Winning Ad Script` and `Angle Headline` on Product and `About Product` on Scripting are read-only, so
build them as lookups into the linked tables.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add an Airtable credential with your personal access token. In every Airtable node, put your base in `YOUR_BASE_ID`, and the
   table in `YOUR_PRODUCT_TABLE_ID`, `YOUR_SCRIPTING_TABLE_ID` or `YOUR_ADS_TABLE_ID`, then select the credential.
3. Add an HTTP Header Auth credential: header name `Authorization`, value `Bearer ` and your Perplexity key. Select it in
   `Product Overview & Customer Research`.
4. Add a Google Gemini (PaLM) API credential and select it in the three Gemini chat models. Add an OpenAI credential and
   select it in `OpenAI Chat Model1` and `OpenAI`.
5. Add a Facebook Graph API credential with your token and select it in `Get FB Ad Accounts`, `Get Ad Campaigns`,
   `Get FB Ad Sets`, `Get FB Ad Contents` and `Facebook Graph API10`.
6. Open `HTTP Request1` and replace `YOUR_SCRAPFLY_KEY` with your Scrapfly key.
7. Save, then press Publish at the top of the canvas (or Shift+P). Open `Webhook` and `Webhook1`, copy their production
   addresses and use them in Airtable.

## Call it

Both webhooks use GET. A button field with an Open URL formula, or an automation with a script step, can make the call.

| Address | Query | What happens |
|---|---|---|
| `ai-vsl` | `action=generateProjectDetails&recordId=<Product record>` | Perplexity profiles the product and its buyers. `Product Details` is filled |
| `ai-vsl` | `action=generateAngles&recordId=<Product record>` | Gemini adds five to eight rows to Scripting |
| `ai-vsl` | `action=generateScript&recordId=<Scripting record>` | Gemini fills `Script` |
| `ai-vsl` | `action=feedbackIteration&recordId=<Scripting record>` | Gemini rewrites `Script` from the feedback field |
| `ad-scraping` | `recordId=<Ads Performance record>` | The ad's video is fetched and transcribed into `Video Script` |

The weekly job starts from `Schedule Trigger2`, so it needs no call.

## How the weekly job and the transcripts work

The job lists your ad accounts, then their campaigns and ad sets, and keeps only those whose status is ACTIVE. For each ad set
it reads the ads with their results to date, keeps the active ones that have results and a video, and creates one Ads
Performance row per ad. The transcript flow reads that row and asks the Graph API for the video's page. Scrapfly loads that page in a
browser, the flow looks through the page's JSON for the video address, and OpenAI transcribes the downloaded file.

## Change it

- Angles: the instructions sit in `Generate Angles`, and the count of five to eight is in its prompt.
- Scripts and rewrites: the instructions sit in `Basic LLM Chain1` and `Basic LLM Chain2`.
- Research: the request text sent to Perplexity is in `Edit Fields2`.
- Weekly job: the interval is in `Schedule Trigger2`, and the ad fields it reads are in the `fields` query of
  `Get FB Ad Contents`.

## Good to know

- Both webhooks are open. Anyone who learns an address can start runs that spend your keys, so add authentication to the
  webhook nodes or keep the addresses private.
- A rewrite replaces `Script`. Copy the old text first if you want to keep it.
- The script prompts read the fields `Time` and `Feedback`, but the file's own Scripting schema calls them
  `3️⃣ Select Script Length` and `4️⃣ Feedback`. Make the field names and the expressions agree.
- `Update Product Details` clears `2️⃣ Generate Angles` and leaves `1️⃣ Generate Product Details` as it was.
- `Airtable9` creates a new row for each active video ad every week and never updates an older one.
- `Edit Fields6` takes conversions from `actions[4]` and conversion value from `action_values[8]`. Those positions fit one
  account's data, so check them against yours.
- `Wait` holds 30 with no unit, and n8n's default unit is seconds, so it pauses 30 seconds. Set minutes there if you
  meant them.
- The three Gemini nodes name an experimental model, `models/gemini-2.5-pro-exp-03-25`. If it is gone, pick a current one.
- The transcript flow depends on how Facebook builds its video page, so it can stop working when that changes. Check
  Facebook's and Scrapfly's terms for your use.
- Product notes and scripts go to Perplexity, Google and OpenAI. Ad videos go to Scrapfly and OpenAI. Ad results go to Airtable.
```

## What is in it

2 files, 118 KB, downloaded as a zip.

```text
README.md  7 KB
workflow.json  111 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 46 steps, starting when its webhook is called or on a schedule
- AI: 5 steps call an AI model: Generate Angles, Parsing, Basic LLM Chain1, Basic LLM Chain2 and OpenAI
- Sign-ins: Signs in to: Airtable, Perplexity, Facebook Graph API, OpenAI, Google Gemini and Scrapfly
- API keys: No API key is left in the file; 1 blank in it for your own key
- Step types: Mindket’s checker reads all 13 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/fb0fd54a-eb0e-4ce1-9b21-6ca28e9f14f9)
- [Its page on Mindket](https://mindket.com/p/fb0fd54a-eb0e-4ce1-9b21-6ca28e9f14f9)