How to Use n8n with ._Template 168 Ecommerce Descricao Categoria Seo Ia

If you run an ecommerce catalog with more than a few hundred SKUs, you already know where the bottleneck is: product descriptions. Every new product needs copy that reads well, includes the right category keywords, and doesn't sound like it was cloned from the supplier's spec sheet. Doing it by hand means one of two outcomes — you either pay a copywriter per SKU and watch margins evaporate, or you paste the manufacturer text and quietly kill your organic rankings with duplicate content. Template 168 (Ecommerce Descrição, Categoria, SEO, IA) solves this with an n8n workflow that generates unique, category-aware, SEO-optimized descriptions at scale using an LLM. This article walks through the problem, the architecture, and exactly how to wire it up.

The Problem: Descriptions Don't Scale Manually

Ecommerce copy has three competing demands that make it uniquely painful to produce. First, it has to be unique — Google penalizes duplicate descriptions, so copying the vendor's blurb across 40 stores that all sell the same product means nobody ranks. Second, it has to be category-aware — the language, buyer intent, and keyword set for "industrial power tools" is nothing like "organic skincare." Third, it has to be consistent in tone and structure so your product pages feel like one brand, not fifty freelancers.

A human can nail all three for ten products. At a thousand SKUs, quality collapses or cost explodes. Worse, the work is recurring: every new supplier feed, every seasonal drop, every marketplace expansion regenerates the same problem. What you actually need is a pipeline — something that ingests raw product data, understands the category context, and emits publish-ready copy without a human touching each row. That's exactly the shape of an n8n workflow.

The Solution: An AI Copy Pipeline in n8n

Template 168 treats description generation as a data transformation, not a creative task. The flow is straightforward: pull products that lack a good description, enrich each one with its category context, send a structured prompt to an AI model, validate the output, and write it back to your store. n8n is the right tool because it handles the unglamorous parts — pagination, rate limits, retries, and field mapping — that would otherwise become brittle glue scripts.

The core nodes in the template are:

• Schedule Trigger — runs the batch nightly, or a Webhook node if you want to fire it from a product-import event.
• HTTP Request (or a native store node like Shopify/WooCommerce) — fetches products missing SEO copy.
• Set / Edit Fields — normalizes each product into a clean object: title, attributes, category path, target keyword.
• AI Agent / Basic LLM Chain node — the engine that writes the description from a category-specific prompt.
• Code node — validates length, strips markdown, checks the keyword actually appears.
• HTTP Request (PUT/PATCH) — writes the finished description and meta fields back to the platform.

Because it's category-driven, the same workflow serves your entire catalog. The category becomes a variable that reshapes the prompt, so a single flow produces distinct voices for every section of the store.

Step-by-Step Setup in n8n

1. Import the template and set credentials. Load Template 168 into your n8n instance. Open the Credentials manager and add two: your store's API key (Shopify Admin API, WooCommerce consumer key/secret, or a generic HTTP header auth) and your AI provider credential. For the language model, use the Anthropic Chat Model node connected to a Claude model — claude-sonnet-5 is the sweet spot for high-volume copy generation, giving you strong instruction-following at a per-SKU cost that stays economical across thousands of products.

2. Configure the product fetch. In the HTTP Request node, set the method to GET and point it at your products endpoint with a filter for empty or flagged descriptions. Enable Pagination (Response → "Next page" via cursor or page param) so the workflow walks the whole catalog instead of stopping at the first 50. Set a reasonable Batch Size in the following Loop Over Items node — 10 to 20 items per batch keeps you inside API rate limits.

3. Build the category-aware prompt. This is where the template earns its name. In the AI Agent / Basic LLM Chain node, write a system prompt that injects the category dynamically:

You are an ecommerce copywriter for the "{{ $json.category }}" category. Write a 90–130 word product description for "{{ $json.title }}". Naturally include the keyword "{{ $json.target_keyword }}" once. Lead with the primary benefit, cover two key attributes ({{ $json.attributes }}), and close with a use-case. No hype, no fake urgency. Return plain HTML using one <p> and one <ul>.

Set the model temperature to around 0.6 — high enough to avoid template-sounding repetition across similar SKUs, low enough to stay on-brief. Enable structured output if you want the meta title and meta description returned as separate JSON fields in the same call.

4. Validate before you write. Add a Code node after the model. Reject anything under 60 words, confirm the target keyword is present, and sanitize the HTML so no stray backticks or markdown reach your storefront. Route failures to a NoOp or a Slack alert instead of writing garbage back:

if (!$json.description.includes($json.target_keyword)) { return []; }

5. Write back and log. The final HTTP Request node does a PUT/PATCH to update the product's body_html (or equivalent) plus the SEO meta fields. Append a Google Sheets or database node to log every SKU processed, so you have an audit trail and can re-run only the failures. Turn on the workflow's Retry On Fail setting (3 attempts, 5-second wait) on both HTTP nodes to survive transient API errors.

The Benefits: Speed, Consistency, and Ranking

Once this runs, the economics change. A catalog that took weeks of copywriting is processed in a single overnight batch. Every description is unique, which removes the duplicate-content penalty that flattens most drop-ship and marketplace stores. Because the keyword and category are injected programmatically, your on-page SEO is consistent by construction — you're no longer hoping a freelancer remembered the target term.

The compounding win is reuse. The same workflow that backfills your existing catalog now runs on every new product automatically via the webhook trigger. New SKUs arrive with publish-ready, optimized copy the moment they hit your feed. Your team stops writing descriptions and starts reviewing exceptions — a far smaller, higher-leverage job. And because the tone lives in one prompt, rebranding your entire catalog's voice becomes a one-line edit instead of a thousand rewrites.

Common Pitfalls to Avoid

Skipping validation. The single biggest mistake is trusting model output blindly and writing it straight to production. Always gate on length, keyword presence, and clean HTML. One malformed description on a live product page erodes trust faster than a missing one.

Ignoring rate limits. Firing all SKUs in parallel will get you throttled or banned by both your store API and the AI provider. Use Loop Over Items with batching and a small Wait node between batches. Slower and complete beats fast and half-finished.

Generic prompts. If you don't inject the category, you get bland copy that reads the same for a drill and a face cream — defeating the entire point. The category variable is the workflow's differentiator; treat it as required, not optional.

No idempotency. Flag processed products (a metafield or a "seo_generated" tag) so a re-run doesn't overwrite good copy or double-bill you for AI calls. Filter these out in the initial fetch.

Temperature extremes. Set it too low and every description sounds cloned; too high and you get invented specs and off-brand claims. Stay in the 0.5–0.7 band and spot-check a sample from each category before scaling to the full catalog.

Wire it up carefully, validate hard, and Template 168 turns your product catalog from an SEO liability into an asset that maintains itself.