Session 17: Facebook Ads Competitor Research & Replication

Meta is legally required to publish every active ad in its Ad Library. That turns your competitors' most expensive lesson — which creatives actually convert — into a free, public dataset. Agencies, rivals and new entrants all mine it; the session's whole workflow is built on this one fact.

The reading skill is knowing which ads are winners. Three signals: how long the ad has run (six months of continuous spend means it converts — nobody pours budget into a loser), how hard the advertiser is doubling down on it, and the strength of its call to action. Duration is the sharpest of the three, and the scraper returns start and end dates precisely so you can filter on it.

Deborah asked the uncomfortable question directly: isn't this plagiarism? The trainer's line is clean. Duplication — same image, same copy, your logo — is plagiarism, and it also quietly destroys you: 'you don't want to become another Nike.' A me-too brand caps its own ceiling.

Intelligence is different: you take the competitor's proven structure — the messaging angle, the visual approach, the offer framing — and regenerate it with your product, your story, your positioning. That's why the workflow's generation prompt feeds the competitor's headline and body text in as *example context* while hard-constraining the output to 'only my product, only my brand.' The winner's skeleton, your flesh."

Two inputs precede any generation. First, reference images of your own product — five to ten, generated in ChatGPT or Gemini (Nano Banana) if you don't have real shots — because without a reference the AI has nothing of yours to build on. Second, the competitor's winning ads as structural inspiration.

From those, the pipeline produces multiple variants — Kenco ad 1, 2, 3 — usually the same image with small copy variations: 'grab your summer deal', 'buy 1 get 1', 'hurry up', 'limited slots'. That's A/B testing: you can't predict whether the urgency line or the offer line converts, because it depends on the audience, the brand language, and the ads' stickiness — whether they actually convert. One variant may win engagement while another wins conversions. The trainer's aside: Meta's delivery system itself is remarkably good at finding which works — 'our job is only to create the workflow, create these images, and push it to Meta. Meta does the rest.'

Deborah asked why bother with a workflow when a Claude Code CLI session could scrape and generate in one shot. The answer is about what survives the run. A CLI transcript is a one-off: it worked, it's gone, and only you could drive it. An n8n workflow with a form on the front is infrastructure — anyone can submit the form, it runs identically every time, and it can be wrapped, branded and priced.

This is the session's business frame: the workflow *is* the product. Agencies, growth marketers and GTM teams all need exactly this; you can run it as a service, sell access to it, or drop a Lovable UI on top and productize it fully. The trainer built it on a 14-day n8n trial precisely to show there's no infrastructure moat."

The 'On form submission' node generates a hosted form and fires the workflow when it's submitted. Three fields here: a product dropdown (Kenco Coffee, HV Sneakers, HV Skincare — the trainer's point is any product type works), a text field for the competitor's Facebook URL with a placeholder showing the expected shape, and a number field for how many ads to process, capped at ten.

Every field is marked required, and that's doctrine rather than fussiness: the workflow spends real money downstream (scraper credits, image-generation tokens), so malformed or missing input has to die at the door. The form is simultaneously the product's UI — this is what a client would see — and its validation gate."

The working setup is a split screen: ChatGPT left, n8n right. The key move is context first — copy the entire workflow JSON out of n8n and paste it into the chat, so the model sees every node, field name and connection before being asked for anything. Then each request is small and specific: 'write the JavaScript for a code node that outputs product_name, product_image_URL, product_brief, competitor_URL, number_of_ads.'

Two disciplines make this reliable. Naming: ask for a standard output shape (snake_case keys) so every downstream node reads predictably. And economics: a code node runs free forever, while an OpenAI node burns tokens on every execution — so anything deterministic (mapping, filtering, parsing) gets generated once as code, and paid AI nodes are reserved for genuine judgment like image analysis and generation. When a node fails, the same loop debugs it: paste the error, get the fix. 'Best superpower is an LLM.'"

Downstream nodes need your product image as binary data, fetched by an HTTP GET from a public URL. Any host works: your own site, a CDN, Unsplash for placeholders, free hosts like ImgBB, or Google Drive. The trainer generated a Kenco shot with Gemini, uploaded it to Drive, shared it, pasted the link — and the node returned an HTML doctype instead of an image.

The trap: Drive's share link points to Google's HTML *viewer page*, not the file. Browsers render that fine, so humans never notice; an HTTP node just sees a webpage where an image should be. The fix (via the ChatGPT debugging loop) is converting to Drive's direct-download URL form. The general lesson outlives Drive: 'public link' and 'direct file URL' are different things, and automation needs the second."

Once the product image is downloaded as binary, the AI nodes ahead want it in a form they can accept inside a JSON payload. Base64 encoding rewrites the binary as plain text — a very long string of letters and digits — which travels inside JSON like any other field.

In n8n this needs no code at all: 'Extract from File' plus 'Move to Base64 String' are prebuilt nodes, chained after the download. The trainer also framed a cost angle: with the image held once as a compact string and referenced by later steps, you avoid repeatedly shipping raw binary through multiple AI nodes as the workflow fans out into ad variants."

Apify is a marketplace of hosted scrapers ('actors'). Search 'Facebook ads scraper', take the official one — built by Apify itself, ~29,000 users, generous free plan — give it a brand's Facebook URL, and it finds the Ad Library entries on its own and returns structured JSON: page info, and per-ad images, copy text, CTA, placement network, and the crucial published/start/end dates.

Integration into n8n is the ChatGPT loop again: paste a sample of the scraper's JSON into the chat, ask for a curl command that calls the actor via Apify's API, and import that curl straight into an n8n HTTP node — n8n converts a pasted curl into a configured node. Add your Apify API credential (n8n flagged the hardcoded token and moved it into a proper credential automatically), and the workflow now pulls fresh competitor ads on every run."

First, Loop Over Items with batch size 1: instead of the whole ad array flooding downstream nodes at once, each ad flows through the expensive analyze-and-generate steps individually — sequential, debuggable, and each iteration independently visible.

Second, filtering — because Apify's JSON is heterogeneous. Different ads store their images in different fields (cards, image, previews), some are video-only, some are logo-only with no copy. A ChatGPT-generated code node normalizes each ad and marks whether it has an image, body text, headline, CTA and page name; a Filter node then passes only has_usable_image = true. Everything downstream sees clean, uniform objects — which both saves tokens and removes the junk inputs that make generation models hallucinate."

Two paid AI nodes close the pipeline, both running on n8n's built-in OpenAI credits (about $2 of free usage — no API key needed to follow along). First, an Analyze Image node (model as heard: 'GPT 5.5') reads the competitor's downloaded ad image — as binary, from the earlier download — and produces a text understanding of its visual approach. That understanding, not the pixels, feeds generation: the plagiarism boundary made mechanical.

Second, a Generate Image node on GPT Image 2 ('gives much better results', per the trainer) runs a system prompt that ChatGPT itself drafted: 'You are a senior performance ad creative director…' with template slots for product name, brief and reference image, plus the competitor's headline and body as example context. The first run produced a fluent ad — in Spanish, because Nespresso's scraped regional ads were Spanish and the model inherited the language of its inputs. The fix was a stricter prompt version with hard rules: only my product, only my brand, only English text; no competitors, no foreign language, no watermarks, no mockups. Second run: clean English ad — 'Rich coffee, real moments… shop now.'"

Technically, nothing prevents wiring the pipeline straight into Meta's ad platform. The trainer refuses on purpose: these images represent your brand, generation is probabilistic, and one bad ad shipped automatically costs more reputation than the automation saves. So the final node uploads each generated creative to Google Drive, where a human reviews before anything goes live.

This is the general pattern: fully automate the expensive research and production, keep a cheap human checkpoint at the exact spot where errors become public. The trainer's own final check demonstrated the gate working — confirming English text, a clear CTA, and no competitor bleed-through before calling it done."