Every Monday a retailer's promotions feed lands, and every promotion in it needs its own paid ad: a headline, a line of main text, a short description, a call to action, an image, a landing page, a schedule and the regions it runs in. Done by hand that's a weekly copy-and-paste marathon. Done badly by an AI, it's a made-up discount in a paid ad, which is not a typo. It's a legal problem with a cost-per-click attached.
So I built an n8n ad automation for a client that does the whole job. It turns the weekly feed into ads and sends them to the ad network: about 200 ads a week, and about 8 hours a week the team gets back. People call it an AI agent. I call it that too, in the title, because that's what people search for. It's also a decent example of what AI automation for marketing teams looks like once it leaves the demo stage, and you'll see in a minute why the word "agent" is doing some heavy lifting.
Here's the idea the whole build hangs on: the AI does exactly one job, writing short copy from facts it's handed. Everything a wrong ad could cost you (prices, discounts, urgency, duplicates) is checked in plain code before anything goes out. The prompt asks. The code enforces.
This is the kind of job I take on at growthvibes.ai. This article isn't a node-by-node tour. It's the six rules behind the nodes, with screenshots of the real workflow, the prompt, the checks, and the thing that broke in every single test run.
What the workflow does, in six stages
The n8n workflow runs in six stages, left to right: get the feed, check each product, work out the facts and write the copy, check the copy, send it, and report what happened. Only stage three calls an AI model. The other five are plain logic, and each stage has a way out for anything that shouldn't become an ad.
Here's the whole thing after a successful test run. Green means the node ran; the little numbers on the lines are how many items passed through.

That red triangle under the AI step is the most honest pixel in the screenshot. In every test run, at least one answer from the model broke a length limit, the schema caught it, and the node retried. We'll get to what that retry costs, because it's not what I expected.
In plain words, the six stages:
- Get the feed. Pull the retailer's promotions and check the feed itself looks right before touching anything inside it.
- Check each product. Split the feed into one item per promotion and run eight true/false checks on each one.
- Facts + AI. Code calculates the sale price and formats prices and dates. Then the model writes the copy from those facts, and nothing else.
- Check the copy. n8n's Guardrails node blocks banned words, then a fact check proves every price, percentage and urgency word is real.
- Send. One node builds the ad in the network's format, and the send carries an idempotency key so a re-run can't duplicate ads.
- Run report. Collect everything that happened and write one line per outcome that a person can read without opening n8n.
And here's the part the screenshot doesn't show well: where a bad ad gets off the train.
Source: growthvibes.ai
Three exits, and they're sized to the damage. Hold that thought until Rule 4.
It's called an agent, but only one step uses AI
Is this an AI agent? Generously, yes. Strictly, no. One node asks a model for words. Every decision around it (what to skip, what to check, what to send, when to stop) is plain logic that does the same thing every time. That's not a weakness. It's the reason it can run every week without me watching it.
If you want the definition I'm using here, it's in what makes something an AI agent.
My test for the word "agent" is three questions: who picks the next step, can it act without a sign-off, and does it give the same result twice? Software only earns the word when it picks its own steps and acts on its own. This workflow fails the first question on purpose. The path through it is drawn on a canvas; the model never decides what happens next.
The wider question, which business jobs are worth an agent at all, is in where AI agents earn their keep.
So by my own definition it's a workflow with one model call. And I think that's what most first AI agents should be. Build a real agent only when you can't know the number of steps in advance. For "turn this week's promotions into ads", you can. There are six. They're the same every Monday. I wrote a longer guide on how to build AI agents that argues this properly; this build is that argument with a client attached.
I'm not alone in this, which is a relief. n8n's own Production AI Playbook (last updated 12 August 2026) puts it more bluntly than I would: the fix for unreliable AI workflows "isn't more AI. It's less of it." Clean the data before the model, validate after it, route by rules. That's this whole article in two sentences.
I know some people will say a workflow with one LLM call is just automation with good marketing. Fair. But the name matters less than the split, and the split is the one thing I'd copy:
If code can do it, code does it. The model gets the one job code is bad at: writing a sentence a person wants to read.
Rule 1: check the feed before anything costs money
Check the input twice before the AI sees it: once for the feed as a whole, once for every product in it. A broken feed stops the run with a clear message. A bad product is skipped with the reason written down. Either way, no model call is spent on data that was never going to make a good ad.
The first check is blunt. A node called Feed looks right? asks whether the retailer name, id and week exist and whether the list of promotions is empty. If anything is missing, the run stops at Stop: feed format changed, and the stop message lists the top-level keys it did get. Whoever reads it can see at a glance that "promotions" is now called "offers" or whatever creative renaming happened upstream.
If the feed's shape changes, you want one loud failure, not 200 quietly broken ads.

Two small things in that stage earn their place. Settings holds every value that changes between environments in one node: the feed URL, the ad network URL, the run date, the landing page base URL and a prompt_version. That version gets stamped on every ad, so when someone asks "which prompt wrote this?" there's an answer that isn't a shrug. And Get retailer feed retries 3 times, 2 seconds apart, with a 10-second timeout. Feeds fail for boring reasons. Boring reasons deserve a retry, not a pager.
Then each product gets its own checklist. Check promo data is an Edit Fields node used as a list of eight true/false checks:
- has a SKU
- has a product name
- price is a positive number
- discount is between 1 and 90%
- currency is EUR
- the promotion is still running on the run date
- the image is https
- it has store regions
Promo data OK? passes a product only if every check is true. It reads "all checks true" rather than naming each one, so adding a ninth check later needs no other change. A product that fails goes to Skipped: bad input, which keeps the SKU and lists the failed checks as the reason.
In the test run, 5 promotions went in and 1 was skipped with the reason discount_is_valid. I'd set that product up with no discount on purpose. A promotion with no discount is not a promotion, it's a price, and you don't want an AI trying to make it sound exciting.

The trade-off is real, though. Stricter input checks skip more products, and a skipped product that nobody sees is just a missing ad. That's why the skip writes a reason, and why Rule 6 exists.
Rule 2: the AI only gets facts that code already worked out
The model never does maths or formats a price. First, a node calculates the sale price, writes prices the Dutch way (€0,99), turns the dates into a Dutch range ("27 juli t/m 2 augustus") and sets a low-stock flag. The model receives only those finished facts and copies them. Models are bad at arithmetic and formats. Code isn't.
The node is called Facts for the AI, and it's the least glamorous node in the workflow and probably the most important. A feed gives you original_price: 1.29 and discount_pct: 23. If you hand that to a model and ask for an ad, you've asked it to multiply, round, pick a decimal separator and decide whether "23%" or "23 procent" sounds better. Four chances to be creative with a number. In a paid ad, creative numbers are the whole problem.
So the model gets this instead (the first test product, placeholders and all):
{
"sku": "SP-10482",
"product": "Halfvolle melk 1L",
"brand": "DailyFarm",
"category": "dairy",
"sale_price": "€0,99",
"original_price": "€1,29",
"discount": "23%",
"valid": "27 juli t/m 2 augustus",
"low_stock": false,
"retailer": "Buurtsuper"
}Every value the ad could possibly need is already a finished string. The model's job is reduced to arranging them into Dutch that a person would tap on. That's the facts-object pattern, and it's the one thing in this build I'd copy into any AI automation that writes about prices, dates or quantities.
The model is Claude Haiku 5.5 from Anthropic, at temperature 0, with a 500-token cap. Anthropic bills it as its fastest, most cost-efficient model: the pricing page lists it at $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100K tokens (checked on 6 November 2026). Temperature 0 because I don't want the ad to be surprising. I want it to be correct and readable, in that order.
Here's where I part ways with the usual advice. n8n's playbook suggests a fast, cheap model for classification and a more capable model for generation. For long, open-ended copy, I'd agree. For a 40-character headline built from facts that code already formatted and code will check again afterwards, a bigger model buys you nothing except a bigger invoice. Spend on checks, not on a bigger model. The checks are what make the ad safe; the model only has to make it readable.
Rule 3: every rule in the prompt has a check in code
A rule that only lives in the prompt is a suggestion. Every one of the nine rules in this prompt has a matching check after the model answers: in the output schema, in n8n's Guardrails node, or in a fact check against the real values. The prompt asks the model to behave. The code proves it did.
Here's the system prompt, word for word (with the placeholder brand already swapped in):
You write short Dutch (nl-NL) ads for a deals app that shows supermarket promotions.
You get the facts for ONE promotion. Write one ad for it.
Hard rules:
1. Use only the facts you are given. Do not invent prices, discounts, dates, product features, health claims or comparisons.
2. Prices: write them exactly as they appear in the facts (for example €0,99). No other amounts.
3. Discount: if you mention it, use exactly the discount from the facts (for example 23%).
4. Scarcity or urgency (op=op, bijna uitverkocht, beperkte voorraad, laatste kans, zolang de voorraad strekt, voordat het weg is, wees er snel bij) is only allowed when low_stock is true.
5. Never use these words: gratis, free, beste, goedkoopste, laagste prijs, garantie.
6. Dutch only, informal "je". No English words.
7. Length limits: headline max 40 characters, primary_text max 125 characters, description max 30 characters.
8. cta must be one of: SHOP_NOW, GET_OFFER, LEARN_MORE.
9. sku_echo must be the exact sku from the facts.
If a rule is hard to follow, keep the copy plain. Never break a rule to make the ad sound better.That last line is my favourite. It's the closest thing to a brand guideline a model will actually follow: when in doubt, be boring. Boring doesn't get a compliance email.

Notice sku_echo. The model has to repeat the SKU it was given, which costs a handful of tokens and lets code confirm the ad is about the right product. When you're running 200 items through the same node, "the milk ad ended up with the egg price" is not a theoretical bug.
The answer goes through a Structured Output Parser (I named it "Ad copy schema"): JSON with sku_echo, headline (max 40 characters), primary_text (max 125), description (max 30) and cta from a fixed list. One detail worth knowing: n8n's own docs on the parser warn that structured output parsing "is often not reliable when working with agents" and steer you to a plain LLM chain. That's why this is a Basic LLM Chain and not an AI Agent node. One short answer per item doesn't need an agent; it needs a gate.
And the schema is a gate, not a promise. It checks shape and length. It cannot tell you whether €0,99 is the right price. That needs two more layers.
Layer one: the Guardrails node, for words. n8n shipped it in version 1.119.0 on 3 November 2025, so a lot of older tutorials still build keyword filters by hand. I use its keyword list for the banned words (gratis, free, beste, goedkoopste, laagste prijs, garantie) and a regex for common English words. An ad that trips it goes to Blocked by guardrails with the matched words as the reason and the draft kept for a person.
Layer two: a fact check, for facts. This is an Edit Fields node with one true/false row per rule: the SKU matches, the three lengths are within limits, every price in the copy is either the sale price or the original price, every percentage equals the real discount, and urgency wording appears only when low_stock is true.

The price check is one expression. It finds every euro amount in the copy and checks each one against the two real prices. The discount check finds every percentage and compares it with the real discount. If the model writes €0,89 because it felt generous, the check returns false and the ad never reaches the network.
Why both layers? Because the Guardrails node's documented checks (keywords, jailbreak, NSFW, PII, secret keys, topical alignment, URLs, a custom LLM check and a custom regex) are all about what kind of text this is. None of them compares a price or a percentage with the real value. Several of them, the LLM-based ones, need a chat model connected to judge the text, which puts a model back in charge of checking a model. For banned words, Guardrails is great. For "is this the right price", you write the check yourself.
Here's the full map, which I'd honestly recommend building for any prompt you put into production:
| Prompt rule | The check that enforces it |
|---|---|
| 1. Use only the facts given | Fact check: prices, percentages and urgency compared with the real values |
| 2. Prices exactly as in the facts | Fact check: every price is the sale price or the original price |
| 3. Discount only as given | Fact check: every percentage equals the real discount |
| 4. Urgency only when low_stock | Fact check: urgency words only when low_stock is true |
| 5. Banned words | Guardrails node: keyword list |
| 6. Dutch only | Guardrails node: regex for common English words |
| 7. Length limits 40 / 125 / 30 | Schema max lengths, plus length rows in the fact check |
| 8. cta from a fixed list | Schema: one of SHOP_NOW, GET_OFFER, LEARN_MORE |
| 9. sku_echo equals the SKU | Schema field, plus the SKU match in the fact check |
If a row in that table is empty, that rule is a wish. The prompt asks. The code enforces.
Rule 4: fail in proportion
Not every failure deserves to stop the run. A bad product is skipped. A bad ad goes to a person with the draft kept. Banned words are blocked. The whole run stops only when something big is broken: the feed changed shape, the ad network refused a valid ad, or nothing at all was delivered. A partial week still ships.
This is the rule most AI automation templates skip. They end up as either a workflow that dies on the first weird product (and then 199 good ads don't go out because of one bad image URL), or one that never dies at all and cheerfully ships garbage. Both are the same mistake: one response for every kind of failure.
So each failure gets the smallest response that's still safe:
| What goes wrong | What the workflow does | Does the run keep going? |
|---|---|---|
| The feed is missing the retailer, the week or the promotions | Stop: feed format changed, listing the keys it did get | No |
| A product fails a check (no discount, http image, expired) | Skipped: bad input, with the failed checks as the reason | Yes |
| The copy has a banned word or English | Blocked by guardrails, with the matched words and the draft | Yes |
| A wrong price, percentage, urgency word, length or SKU | Needs review, with the failed checks and the draft | Yes |
| The AI answer doesn't fit the schema | Retried up to 3 times, then the run stops | Only if a retry works |
| The ad network refuses an ad that passed every check | Stop: ad network refused, with what to fix | No |
| Zero ads delivered | Stop: nothing delivered, listing every SKU and its reason | No |

The stop messages are written in plain English on purpose, because the person reading them at 6:15 on a Monday isn't necessarily the person who built the workflow. "Stop: ad network refused" doesn't just say no. It says our own checks passed, so the network's API has probably changed, fix Build ad payload, and re-running is safe. That's three sentences of thinking the reader doesn't have to do.
The pieces are all standard n8n. Nodes have an On Error setting with a "Continue (using error output)" option that sends failures down their own branch, and the Stop And Error node fails a run on purpose with your message. The design part is deciding which failure gets which exit. That design is the real work in any AI agents and automation build. The happy path is the easy part.
One honest caveat. A partial week that ships can hide a quiet problem if nobody reads what was skipped or held back. Failing in proportion only works if someone can see the proportions. Which brings us to the send, and then the report.
Rule 5: make re-running safe
A re-run should never create a second ad. Every ad gets an id built from the retailer, the SKU and the week, and the send puts that id in an Idempotency-Key header. A retry or second run for that week gets the same ad, not a duplicate. One node owns the ad network's format, so an API change means one fix.
Two nodes do this job, and both are deliberately dull.
Build ad payload is the only node in the workflow that knows what the ad network wants. It assembles the ad id, the advertiser, a campaign id and name per retailer and week, the creative (copy, image, landing URL with UTM tags), the offer, the schedule, the targeting (country and regions), the locale, and a bit of meta: the prompt_version, the source feed and when it was created. When the network changes its API, there is exactly one node to fix. Not six. Not "somewhere in the expressions".
Send to ad network is an HTTP POST with a 10-second timeout, 3 retries, and the error output switched on, so a refusal goes down its own branch instead of crashing the run. The header that matters is Idempotency-Key, set to the ad id. In the test run, the first delivered ad came back as:
ad-sp-10482-2026-w31Same product, same week, same id. Run the workflow twice on a Monday by accident and the second run asks for the same ad, not a new one.

Now the skeptic's bit, because "safe to re-run" is a bigger promise than it sounds. An idempotency key is a request, not a guarantee. The guarantee lives on the server that receives it. Stripe's API reference, which is the clearest public write-up of how the header works, describes the deal: the server saves the result of the first request with a key and returns that same result for retries, compares the parameters, and errors if they differ. It also says keys can be pruned after at least 24 hours. That's Stripe's implementation, and Stripe is a payments API, not an ad network. I'm citing it for what the header does, nothing more.
The lesson carries over anyway: a re-run is only safe if the receiving API honours the key. If yours ignores the header, you need a second defence, like checking whether the ad id already exists before you send. And keep the key meaningful (retailer, SKU, week), never personal data. A key you can read is a key you can debug.
Rule 6: end every run with a report a person can read
Every run ends with one short table: how many ads were delivered, skipped, sent to review or blocked, with the SKUs and the reasons. Nobody should have to open n8n and click through executions to find out what happened this week. And if not a single ad went out, the run fails loudly instead of reporting a quiet zero.
Three nodes close the loop. Collect results is a Merge node with four inputs: delivered, skipped, needs review and blocked. Anything delivered? checks that at least one ad went out. If not, Stop: nothing delivered fails the run and lists every SKU with its reason, because zero out of 200 means something bigger is wrong than one bad product. Then Run report (a Summarize node, split by status) writes one line per outcome.
Here's the report from the test run:

In plain text, that's:
delivered: 4 SP-10482, SP-20917, SP-41155, SP-58730
Accepted by the ad network as ad-sp-10482-2026-w31 | ...
skipped: 1 SP-33208
Failed input checks: discount_is_validThat's the whole report. If the report needs a meeting to explain, it isn't a report. One line per outcome, the count, the SKUs, the reason. A marketer can read it on a phone. So can the person who has to decide whether a skipped product was a feed problem or a real non-promotion.
If I added one thing, it would be a single number in that report: model calls per ad delivered. In a clean run it sits at 1. Anything above 1 means something is regenerating, and it's the cheapest alarm you can build for a runaway retry (more on that below).
How I tested it without touching the client's systems
I tested it against fakes, not the client's real feed or ad network. A second small n8n workflow plays both ends: a retailer feed I can edit to break on purpose, and an ad network that checks each ad against its format and answers 201 for accepted or 422 for refused. Every failure path got triggered on purpose first.
The fake feed let me test a missing field, a renamed field and a format change, which is how the "feed format changed" stop got its useful message. The fake network has a switch that makes it behave as if it had renamed headline to title (my pretend "API v2"), so every ad gets refused. That's how I tested the "ad network refused" stop: flip the switch, run, watch it fire exactly as designed. Breaking your own test double is oddly satisfying. Cheaper than breaking production, too.
It's the same check-then-publish thinking that runs through the SEO content automation I built for this site: decide what must never ship, write the check for it, and only then let the machine publish. Different output, same skeleton.
I think SEO automation and AEO automation will go the same way as ad automation. The teams that come out fine won't be the ones with the cleverest prompts; they'll be the ones with a check behind every rule. That's the angle I take in my SEO and AEO work too.
What I'd change: the retry that doubles the bill
The model broke a length limit in every test run, and the way n8n retried it doubled the AI calls. One 41-character headline against a 40-character limit meant the node retried, and the retry regenerated all four ads: 8 model calls for 4 ads. The fix is to retry only the item that failed, with the error in the prompt.
Let's start with the embarrassing part, which isn't mine, strictly. The model can't count characters. The prompt says "headline max 40 characters" in plain words. The model writes 41. Or main text over 125. In every single test run, at least one answer broke a limit. The schema caught it every time, so no long headline ever got near the network. But it tells you something worth tattooing somewhere visible: keep the limit in the prompt, but only trust the schema and the length checks.
The surprise was the retry. When one answer fails the schema, the node fails, and Retry On Fail reruns the node. In my test, that meant the AI step ran again for every item in the batch, not just the one with the long headline. Three good ads thrown away and rewritten to fix one bad one.
I want to be careful here, because this rests on my test and not on the manual. n8n's docs define Retry On Fail in one line, as a node that "reruns until it succeeds", and say nothing about what that does to a batch. Other builders are clearly hitting the same wall: there's a community thread from someone running a Basic LLM Chain with structured output, getting "Model output doesn't fit required format", asking whether the chain can be retried, and no accepted answer on the page. As of 6 November 2026, I couldn't find a per-item retry option in the docs either.
This is where the two bits of n8n's own advice disagree. The node setting is a blind rerun. The playbook recommends something smarter for format failures: loop back to the AI step with the error message in the prompt, and stop after 2 or 3 attempts. I'm on the playbook's side, and I'd go one step further: do it per item. Send schema failures down their own branch and retry only that item, with the reason it failed. The model gets told what went wrong, and the three good ads stay good. That's the fix I'd build next; it isn't shipped, so I'm not going to tell you it worked.
Now the cost view, which is more interesting than scary. Here's an example with assumed sizes (700 input tokens and 120 output tokens per ad, which I haven't measured) at Haiku 5.5's listed prices:
Source: growthvibes.ai, prices from Anthropic
Doubling 200 ads costs about two and a half cents more in this example. At the 500-token output cap, run twice, it's under 13 cents. And n8n doesn't charge for it at all: its pricing page counts an execution as one run of the whole workflow, however many steps or items, so a retry inside a run adds no executions (Starter is 2.5K executions for $20 a month billed annually, Pro is 10K for $50, as of 6 November 2026).
So "the retry that doubles the bill" is true in calls and almost irrelevant in dollars. I'm keeping the heading anyway, because the bill isn't the point. The real cost of a blind batch retry is wasted calls, slower runs, rate limits and failures that hide inside a "success". Code checks cost nothing on either meter; n8n bills by the run and Anthropic by the token, and an if-statement is on neither invoice. The one step that spends on both is the blanket AI retry. That's the step to fix.
It also matches something I believe about AI automation generally: a single workflow like this costs very little to run, and the real ongoing cost is the person who keeps it healthy. Budget for that, not for tokens.
The wider idea has an older name, and I wrote the definition up in a practical guide to business process automation.
When this pattern fits, and when you still need a person to approve
This pattern fits when the volume is high and the things that can go wrong are facts a rule can check: prices, discounts, dates, lengths, banned words. It doesn't fit when the risk is tone, a brand-new claim, or anything you can't write as a true/false check. Those need a person, as does every ad that fails a check.
I rank marketing jobs by what a wrong output costs. Read-only reports are the safest place to start. Drafts a person approves come next. Anything customer-facing or money-spending comes last, and I've always said it needs a sign-off. A paid ad is both customer-facing and money-spending. So how does a workflow that can send ads without a click square with that?
Here's how I reconcile it. For the facts a rule can express, the code checks are the sign-off. A person checking 200 prices by eye is slower and, honestly, worse at it than an expression that compares every euro amount with the real one. Approval steps on high-volume work also tend to decay into rubber stamps; I suspect most "approve all" buttons get pressed by thumbs that stopped reading weeks ago. If you do keep a human approver, test them: plant a deliberate mistake in a draft every few weeks and see if it gets caught.
What the code can't sign off on goes to a person, by design. A failed fact check lands in Needs review with the failed checks listed and the draft kept. A banned word lands in Blocked by guardrails with the matched words. Nothing that fails a check is published. How the client's team handles that review in production is theirs to describe, not mine, so I'll leave it there.
The skeptic has a point too, and n8n's own playbook makes it: start with a high threshold so most items get human review, then lower it as the AI proves itself, and never pass raw AI output straight to a node that changes an external system. I agree with all of it. This build doesn't pass raw output anywhere; it passes output that survived a schema, a guardrail and a fact check. And as of 6 November 2026, n8n lists human approval for tool calls on every cloud plan, so adding a sign-off step is a setting, not a project.
So, the honest split:
before
Code can sign off
- Prices and discounts match the feed
- Lengths fit the ad format
- No banned words, no English
- Urgency only when stock is low
- The ad is about the right product
after
A person still signs off
- Tone and brand voice
- Any new claim or comparison
- Every ad that fails a check
- Changes to the prompt or the rules
If you want the wider map of where this fits, I've written up which AI marketing agents can run real work today and which are still demos. Ad copy from a feed is near the top of that list precisely because the facts are checkable. Brand campaigns are not. If your problem is the paid side more broadly (structure, bidding, reporting), that's a different job, and a different article.
The rule I'd keep if I could only keep one
Back to that Monday feed and the made-up discount that started this. At 200 ads a week, the risk was never that the AI writes a dull headline. It was a confident wrong number that someone pays to show to a lot of people.
The fix wasn't a smarter model or a longer prompt. It was moving every number out of the model's hands and putting a check behind every rule. The prompt asks. The code enforces. If you're building marketing automation with AI agents, start with the facts you can check. If you'd rather not build it yourself, that's exactly the kind of AI automation and agents work I do. Bring your feed. Leave your made-up discounts at home.
Frequently asked questions
How do you stop the AI from making up a discount?
Code calculates the discount before the model is called, the prompt says to use only that number, and a fact check rejects any ad whose percentage differs from the real discount. Prompt plus check, never prompt alone.
The same goes for prices: the fact check finds every euro amount in the copy and accepts only the sale price or the original price. Urgency words are allowed only when the feed says stock is low.
Can n8n publish ads without a person approving them?
Technically yes, n8n can send ads straight to an ad network. It's only responsible when every fact a rule can check is checked in code and every ad that fails a check goes to a person instead.
Tone, new claims and changes to the rules still need a human. n8n lists human approval for tool calls on its cloud plans if you want a sign-off step on top.
How much does it cost to run?
I don't have a real running cost to share. As an example with assumed token sizes, 200 ads cost about 3 cents a week in Claude Haiku 5.5 fees at the 6 November 2026 prices, and n8n bills per run, not per step.
The example uses 700 input and 120 output tokens per ad, which are assumptions, at $0.10 and $0.50 per million tokens. Even with the whole batch run twice, it stays under 13 cents a week at the 500-token cap. The bigger cost is the person who maintains the workflow.
Which model writes the ads, and why a small one?
Claude Haiku 5.5 at temperature 0. The job is short copy from facts code already formatted, and a schema, guardrails and a fact check sit behind it, so a bigger model would add cost without adding safety.
For long, open-ended copy I'd pick a stronger model. For a 40-character headline from a finished facts object, the small one is enough.
What happens when the ad network changes its API?
The ad network refuses the ads, the run stops with a message saying the API has probably changed and that Build ad payload is the node to fix. Re-running afterwards is safe because of the idempotency key.
That assumes the network honours the Idempotency-Key header. If it doesn't, check whether an ad id already exists before sending.
Do I need the Guardrails node if I have a fact check?
Yes, because they do different jobs. Guardrails checks what kind of text it is (banned words, regex patterns, PII, links). None of its checks compares a price or a percentage with the real value. The fact check does that.
I use Guardrails for the banned-word list and an English-word regex, and a separate fact check for prices, discounts, urgency, lengths and the SKU.
