---
title: "Pinterest Automation for Shopify: Create and Schedule Product Pins With AI (+ Free n8n Template)"
description: "Automate Pinterest product pins from Shopify with n8n: AI titles and alt text, headline and review frames, Slack approval and a paced posting queue."
canonical: "https://www.reganmcgregor.com.au/pinterest-automation-shopify/"
published: 2026-11-10
author: "Regan McGregor"
---

# Pinterest Automation for Shopify: Create and Schedule Product Pins With AI (+ Free n8n Template)

> Automate Pinterest product pins from Shopify with n8n: AI titles and alt text, headline and review frames, Slack approval and a paced posting queue.

*Last tested on n8n 2.46, November 2026.*

Pinterest sends buyers to product pages for months after a pin goes up, but resizing photos to 2:3, writing titles for search, and spacing out posts takes hours every week. Paying for a commercial Pinterest automation tool or social app still leaves the writing and image preparation to you while charging per seat or per post. With this Pinterest automation workflow in n8n, your store drafts search-optimised product pins from your real catalogue photos, uses a vision model for accurate alt text, sends every draft to Slack for a one-click review, and books approved pins into a paced queue that publishes through Zernio automatically.

<TemplateCallout
  repo="https://github.com/reganmcgregor/n8n-ecommerce-templates/tree/main/pinterest-automation"
  title="Pinterest product pins template for n8n"
>

- Drafts Pinterest product pins from your Shopify catalogue using a vision model for accurate alt text and a chat model for search-focused titles and descriptions.
- Pads your real product photo to 2:3 for the first pin, then renders HTML headline and customer review frames for later pins without AI-modifying the photo.
- Sends every draft to Slack to approve, edit or skip, then paces approved pins into posting hours through Zernio and logs live Pinterest URLs back to your table.

</TemplateCallout>

## What you'll build

Instead of handing your catalogue to a Pinterest pin generator that invents backgrounds, this workflow keeps a reviewer in Slack while automating the preparation. For the **TP-Link TC85 KIT 2K QHD Solar-Powered Security Camera Kit**, the morning run posts a draft card in `#pins` with the 2:3 padded photo, character counts, vision-written alt text, board, tracked link, and buttons to approve, edit or skip.

![A Pin draft card in Slack for the TP-Link TC85 KIT: Pin 1 · photo, the padded 2:3 product photo, the title (45 characters), description (371), alt text, board and link, and Approve, Edit and Skip buttons.](./_attachments/pinterest-automation-shopify/pin-draft-card-slack.png "A Pin draft card in Slack for the TP-Link TC85 KIT: Pin 1 · photo, the padded 2:3 product photo, the title (45 characters), description (371), alt text, board and link, and Approve, Edit and Skip buttons.")

Across subsequent weeks, each product works through a four-step sequence: the padded product photo first, an HTML headline frame second, a customer review frame third, and a second photo fourth.

![The TC85 KIT's three pins side by side: the plain 2:3 product photo, the headline frame, and the review frame with a sample review.](./_attachments/pinterest-automation-shopify/three-pins-photo-headline-review.png "The TC85 KIT's three pins side by side: the plain 2:3 product photo, the headline frame, and the review frame with a sample review.")

Approving a card books the next paced slot, and once the pin goes live, the hourly sync adds an **Open pin** button. On a store I run, this workflow produced 38 pins in the first four weeks at about one a day, with 23 of them booked and posted by the workflow and 8 drafts skipped in review.

![The live pin on Pinterest titled "Solar Security Camera 2K QHD TP-Link TC85 KIT", with the product's price, the Solar & 4G Security Cameras board and the pin's own stats.](./_attachments/pinterest-automation-shopify/live-product-pin-on-pinterest.png "The live pin on Pinterest titled \"Solar Security Camera 2K QHD TP-Link TC85 KIT\", with the product's price, the Solar & 4G Security Cameras board and the pin's own stats.")

All eight lanes sit on one n8n canvas.

![The Pinterest product pins template in n8n: eight lanes (Setup, Draft, Card, Frame, Render, Review, Book and Sync) and the overview note.](./_attachments/pinterest-automation-shopify/n8n-template-canvas.png "The Pinterest product pins template in n8n: eight lanes (Setup, Draft, Card, Frame, Render, Review, Book and Sync) and the overview note.")

## What you need

You need n8n with [Data Tables](https://docs.n8n.io/data/data-tables/) on a public HTTPS URL (so Slack and Firecrawl can reach your webhooks), a Shopify app with `read_products` and `write_files`, and a Pinterest business account with your website claimed and boards created, connected to [Zernio](https://docs.zernio.com/platforms/pinterest). You also need a Slack app with Interactivity, [Ollama Cloud](https://ollama.com/pricing) for the vision and chat models, and [Firecrawl](https://www.firecrawl.dev/pricing) for the HTML frames. Keep the Pinterest app for Shopify if you use it, as it syncs catalogue pins and shopping ads rather than writing fresh board pins. A Supabase version is in the repo.

## How it works

1. **Setup** runs once to create the `pins` and `pin_reviews` tables, seed one sample review so the review frame works straight away, and list your Pinterest board IDs from Zernio.
2. **Draft** runs every morning and after each approval or skip, keeping up to `max_waiting` (10) drafts in Slack so the channel never floods while matching products to boards, checking the photo with a vision model, writing for search, and checking every rule.
3. **Card** is the single renderer for every pin state (draft, scheduled, posted, skipped, or failed), called by the other lanes so the Slack message always matches the database row.
4. **Frame** serves a 1000 x 1500 HTML page from an n8n webhook that places the untouched product photo above a headline or customer review quote.
5. **Render** screenshots the Frame page with Firecrawl, converts it to a JPEG through wsrv.nl, and stores it in Shopify Files so Slack and Zernio get a lasting URL, deleting the old file whenever a frame is redrawn.
6. **Review** checks Slack's signature on every click, opens the edit modal, refuses to book sample reviews or already-booked pins, cancels scheduled posts in Zernio, and tops up the queue.
7. **Book** spaces out approved pins according to your account's age (`pace`) with random jitter inside daytime posting hours so nothing posts in a burst or gets booked twice.
8. **Sync** asks Zernio every hour about pins whose slot has passed, updates the Slack card with the live Pinterest link or failure reason, and logs one line per pin to `#pins-log`.

## Step 1: Make your boards and connect Pinterest

Treat your Pinterest boards as search topics with keyword-rich descriptions rather than internal store departments, because board names and descriptions help Pinterest understand where each pin belongs in search. Every pin goes to the single board that best matches the product, such as **Solar & 4G Security Cameras** or **PoE Security Cameras**, and you should claim your website in your Pinterest business settings before posting.

Building directly on the official Pinterest API hits a roadblock on day one: under [Pinterest's API access tiers](https://developers.pinterest.com/docs/key-concepts/access-tiers/), every new developer app starts on Trial access, where pins created by the API are sandboxed and visible only to their creator until you pass Standard access review with a screen recording. [Zernio](https://docs.zernio.com/platforms/pinterest) already has approved publishing access, is [free for one or two connected accounts with API access included](https://zernio.com/pricing) (checked November 2026), and schedules a pin in one HTTP Request node.

In the **Setup** lane, add a **Manual Trigger** named `Run once to set up` and connect an **Edit Fields (Set)** node named `Setup settings` holding the Zernio API URL, your Zernio Pinterest account ID, and one product handle from your store so the sample review shows up on a pin:

| Setting | Value |
|---|---|
| zernio_api (string) | `https://zernio.com/api/v1` |
| zernio_account_id (string) | `YOUR_ZERNIO_PINTEREST_ACCOUNT_ID` |
| sample_review_handle (string) | `your-product-handle` |

At the end of the Setup lane, add an **HTTP Request** node named `List Pinterest boards` (`executeOnce: true`) using a Header Auth credential with `Authorization: Bearer YOUR_ZERNIO_KEY`:

| Setting | Value |
|---|---|
| Method | `GET` |
| URL | `{{ $('Setup settings').first().json.zernio_api }}/accounts/{{ $('Setup settings').first().json.zernio_account_id }}/pinterest-boards` |
| Authentication | `Generic credential: Header Auth` |

Running Setup returns your boards and their numeric IDs, which you'll copy into `Draft settings` in Step 3.

## Step 2: Create the pins and reviews tables

Keeping state in an n8n Data Table lets the workflow count how many drafts are waiting in Slack, prevent duplicate bookings when a button is clicked twice, track which review quotes and secondary photos a product has already used, and redraw any Slack card from its saved row.

Between `Setup settings` and `List Pinterest boards`, add two **Data table** nodes (`Create pins` and `Create pin_reviews`, both with `executeOnce: true`), a **Code** node (`Sample review`), and a **Data table** node (`Save the sample review`). Turning on **Reuse existing table** ensures a second run of Setup keeps your existing tables intact:

| Setting | Value |
|---|---|
| Resource | `table` |
| Operation | `create` |
| Table name | `pins` |
| Options > Reuse existing table | `on` |

Give `Create pins` these columns:

| Setting | Value |
|---|---|
| product_id | `string` |
| product_title | `string` |
| handle | `string` |
| pin_no | `number` |
| pin_kind | `string` |
| board_key | `string` |
| board_name | `string` |
| board_id | `string` |
| title | `string` |
| description | `string` |
| alt_text | `string` |
| headline | `string` |
| product_line | `string` |
| review_quote | `string` |
| review_rating | `number` |
| review_author | `string` |
| review_source | `string` |
| image_url | `string` |
| source_image | `string` |
| photo_kind | `string` |
| shopify_file_id | `string` |
| link | `string` |
| problems | `string` |
| status | `string` |
| slack_channel | `string` |
| slack_ts | `string` |
| decided_by | `string` |
| decided_at | `date` |
| post_id | `string` |
| scheduled_for | `date` |
| posted_at | `date` |
| pin_url | `string` |
| error | `string` |

Configure `Create pin_reviews` (`Resource: table`, `Operation: create`, `Table name: pin_reviews`, `Options > Reuse existing table: on`, `executeOnce: true`) with these columns:

| Setting | Value |
|---|---|
| product_handle | `string` |
| rating | `number` |
| quote | `string` |
| author | `string` |
| source | `string` |
| verified | `boolean` |

Connect `Create pin_reviews` to the **Code** node `Sample review`, which seeds one made-up review labelled `sample` so you can test the review frame before adding real customer quotes:

```javascript
// One made-up review so the review frame works straight after import. It is labelled as a sample on the frame,
// and the Review lane refuses to book a pin that uses it. Add your own reviews to pin_reviews (source "own").
return [{ json: {
  product_handle: $('Setup settings').first().json.sample_review_handle,
  rating: 5,
  quote: 'Easy to set up and exactly as described. It still looks new after a month, and I would buy it again.',
  author: 'Sample Customer',
  source: 'sample',
  verified: false
} }];
```

Connect `Sample review` to `Save the sample review` (`Resource: row`, `Operation: upsert`, Data table `pin_reviews`, matching `All conditions` where `product_handle eq {{ $json.product_handle }}` and `source eq {{ $json.source }}`, sending all six fields), then wire it to `List Pinterest boards`.

## Step 3: Pick the products that earn a pin

Because n8n starts every sub-workflow call at the canvas's first **Execute Workflow Trigger**, the workflow uses one trigger named `Called by this workflow` (`Input data mode: Accept all data`) connected to a **Switch** node named `Which lane?`. Each self-call puts a small Set node in front of an **Execute Workflow** node to set `lane`, and `Which lane?` routes `top_up` to `Draft settings`, `card` to `Card settings`, `render` to `Render settings`, and `book` to `Book settings`:

| Setting | Value |
|---|---|
| top_up | `{{ $json.lane === 'top_up' }}` |
| card | `{{ $json.lane === 'card' }}` |
| render | `{{ $json.lane === 'render' }}` |
| book | `{{ $json.lane === 'book' }}` |

In the **Draft** lane, connect `Every morning` (a **Schedule Trigger** at `8:00` daily), `Draft pins now` (a **Manual Trigger**), and the `top_up` output of `Which lane?` to an **Edit Fields (Set)** node named `Draft settings`:

| Setting | Value |
|---|---|
| store_domain (string) | `your-store.myshopify.com` |
| store_name (string) | `Your Store` |
| store_url (string) | `https://www.your-store.com` |
| store_description (string) | `an online store for (what you sell)` |
| language (string) | `English` |
| style_rules (string) |  |
| slack_channel (string) | `#pins` |
| frame_page_url (string) | `https://your-n8n.example.com/webhook/pinterest-pin-frame` |
| product_query (string) | `status:active published_status:published` |
| max_products (number) | `1000` |
| boards (array) | `{{ [{"key": "board-1", "name": "Your first board", "board_id": "PASTE_BOARD_ID", "match": {"title_words": ["solar"], "product_types": [], "categories": []}, "phrases": ["first search phrase", "second search phrase"]}, {"key": "board-2", "name": "Your second board", "board_id": "PASTE_BOARD_ID", "match": {"title_words": [], "product_types": ["Your product type"], "categories": ["Your Shopify category"]}, "phrases": ["first search phrase", "second search phrase"]}] }}` |
| skip_words (string) | `\b(mount\|bracket\|cable\|adapter\|power supply\|battery pack\|replacement\|spare)\b` |
| pin_sequence (array) | `{{ ['photo', 'headline', 'review', 'photo_2'] }}` |
| max_waiting (number) | `10` |
| next_pin_after_days (number) | `7` |
| min_photo_px (number) | `600` |
| review_min_rating (number) | `4` |
| review_max_chars (number) | `140` |
| review_sources (array) | `{{ ['own', 'sample'] }}` |
| image_template (string) | `https://wsrv.nl/?url={url}&w=1000&h=1500&fit=contain&cbg=white&output=jpg&q=90` |
| utm (string) | `utm_source=pinterest&utm_medium=social&utm_campaign=pins` |
| closing_line (string) | `See specs and price at Your Store.` |
| banned_words (string) | `\b(best\|cheapest\|guaranteed\|free shipping\|sale\|buy now)\b` |
| keep_terms (array) | `{{ ['IP', 'PoE', 'NVR', 'HD', 'AI', 'PTZ', '4K', '2K', '4G', '5G', 'LTE', 'QHD', 'Wi-Fi', 'CCTV', 'USB', 'microSD'] }}` |
| chat_model (string) | `gemma4:31b` |
| vision_model (string) | `gemma4:31b` |

Why match boards with rules instead of Shopify categories alone? Every security camera sits in the same Shopify category, so category alone can't separate a solar camera onto **Solar & 4G Security Cameras** and a wired dome onto **PoE Security Cameras**. In `boards`, the first board whose `title_words`, `product_types`, or `categories` match wins, and each board holds two to four search `phrases` gathered from Pinterest search suggestions and [Pinterest Trends](https://trends.pinterest.com/).

Connect `Draft settings` to two **Data table** nodes (`Get all pins` on `pins` and `Get reviews` on `pin_reviews`, both `Operation: get`, `Return all: on`, `executeOnce: true`, `alwaysOutputData: true`), then `Get Shopify token` (`POST` to `https://{{ $('Draft settings').first().json.store_domain }}/admin/oauth/access_token` with `grant_type=client_credentials`), then an **HTTP Request** node named `Get products` (`executeOnce: true`) that pages through Shopify's [products query](https://shopify.dev/docs/api/admin-graphql/2026-10/queries/products) using [Shopify search syntax](https://shopify.dev/docs/api/usage/search-syntax):

| Setting | Value |
|---|---|
| Method | `POST` |
| URL | `https://{{ $('Draft settings').first().json.store_domain }}/admin/api/2026-10/graphql.json` |
| Header X-Shopify-Access-Token | `{{ $('Get Shopify token').first().json.access_token }}` |
| Options > Pagination > Mode | `Update a Parameter in Each Request` |
| Pagination parameter | type body, name `variables`, value `{{ { q: $('Draft settings').first().json.product_query, after: $response.body.data.products.pageInfo.endCursor } }}` |
| Pagination complete when | `Other: {{ !$response.body.data.products.pageInfo.hasNextPage }}` |
| Limit pages fetched | on, max `{{ Math.ceil($('Draft settings').first().json.max_products / 100) }}` |
| Interval between requests (ms) | `250` |

Set the `Get products` body expression to:

```javascript
{{ JSON.stringify({ query: 'query Products($q: String!, $after: String) { products(first: 100, after: $after, query: $q, sortKey: CREATED_AT) { pageInfo { hasNextPage endCursor } nodes { id legacyResourceId title handle vendor productType createdAt onlineStoreUrl descriptionHtml category { name fullName } priceRangeV2 { minVariantPrice { amount } } featuredMedia { ... on MediaImage { image { url width height } } } media(first: 10) { nodes { ... on MediaImage { image { url width height } } } } } } }', variables: { q: $('Draft settings').first().json.product_query, after: null } }) }}
```

Connect `Get products` to a **Code** node named `Pick the next pins`. It checks how many free slots remain under `max_waiting`, drops accessories matching `skip_words` (such as `Ubiquiti UACC-G5-Dome-Ultra-PM Pendant Mount for G5 Dome Ultra`), checks image dimensions and price, allows only one active pin per product at a time, and keeps only board phrases whose distinctive words appear in the product's title or intro so a 4G camera is never called a solar camera:

```javascript
// The query only returns products published to the Online Store; store_url builds the link if Shopify hasn't given one yet.
// Which products get a pin now, and which pin. One pin per product at a time: a product with a draft, scheduled or failed pin waits.
// Each product works through pin_sequence (photo, headline, review, photo_2), one step every next_pin_after_days, skipping a step it can't make
// (no qualifying review, no second photo). First pins always go before anyone's later pins. Only the free slots in max_waiting are filled.
const s = $('Draft settings').first().json;
const pins = $('Get all pins').all().map(i => i.json).filter(r => r.product_id);
const reviews = $('Get reviews').all().map(i => i.json).filter(r => r.quote);
const pages = $('Get products').all().map(i => i.json);
const bad = pages.find(p => p.errors);
if (bad) throw new Error('Shopify: ' + JSON.stringify(bad.errors).slice(0, 300));
const products = pages.flatMap(p => p.data?.products?.nodes || []);
const free = Math.max(0, s.max_waiting - pins.filter(r => r.status === 'draft').length);
if (!free) return [];

const text = h => String(h || '').replace(/<li[^>]*>/gi, '; ').replace(/<[^>]+>/g, ' ').replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&').replace(/\s+/g, ' ').replace(/^[;\s]+/, '').trim();
const words = t => String(t || '').toLowerCase();
const has = (title, w) => new RegExp('(^|[^a-z0-9])' + w.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '($|[^a-z0-9])').test(words(title));
const boardFor = p => s.boards.find(b => (b.match.title_words || []).some(w => has(p.title, w))
  || (b.match.product_types || []).includes(p.productType)
  || (b.match.categories || []).some(c => p.category && (p.category.name === c || String(p.category.fullName).includes(c))));
const skip = s.skip_words ? new RegExp(s.skip_words, 'i') : null;
const day = 864e5, now = Date.now();
const big = im => im && Math.min(im.width || 0, im.height || 0) >= s.min_photo_px;
const base = u => String(u || '').split('?')[0];

const out = [];
for (const p of products) {
  const board = boardFor(p);
  if (!board || (skip && skip.test(p.title))) continue;
  const main = p.featuredMedia?.image;
  const url = p.onlineStoreUrl || (s.store_url.replace(/\/$/, '') + '/products/' + p.handle);
  if (!big(main) || !(Number(p.priceRangeV2?.minVariantPrice?.amount) > 0) || text(p.descriptionHtml).length < 30) continue;
  const id = String(p.legacyResourceId);
  const mine = pins.filter(r => String(r.product_id) === id);
  if (mine.some(r => ['draft', 'scheduled', 'failed'].includes(r.status))) continue;
  if (mine.some(r => Number(r.pin_no) === 1 && r.status === 'skipped')) continue;   // skipping a first pin stops the product
  const last = Math.max(0, ...mine.map(r => new Date(r.posted_at || r.decided_at || r.createdAt || 0).getTime()));
  if (mine.length && now - last < s.next_pin_after_days * day) continue;
  const done = mine.map(r => r.pin_kind);
  const others = (p.media?.nodes || []).map(m => m.image).filter(im => big(im) && base(im.url) !== base(main.url) && !mine.some(r => base(r.source_image) === base(im.url)));
  const review = reviews.filter(r => r.product_handle === p.handle && Number(r.rating) >= s.review_min_rating && String(r.quote).length <= s.review_max_chars
    && s.review_sources.includes(r.source) && !mine.some(m => m.review_quote === r.quote))
    .sort((a, b) => (b.verified === true) - (a.verified === true) || b.rating - a.rating)[0];
  let kind = null, photo = main;
  for (const k of s.pin_sequence) {
    if (done.includes(k)) continue;
    if (k === 'review' && !review) continue;
    if (k === 'photo_2') { if (!others.length) continue; photo = others[0]; }
    kind = k; break;
  }
  if (!kind) continue;
  const pinNo = mine.length + 1;
  const desc = String(p.descriptionHtml || '');
  const cut = desc.search(/<h[2-4]/i);
  const intro = text(cut >= 0 ? desc.slice(0, cut) : desc).slice(0, 800);
  const specs = text(cut >= 0 ? desc.slice(cut) : '').slice(0, 3000);
  // search phrases that fit this product: every distinctive word in the phrase is in the title or intro
  const hay = words(p.title + ' ' + intro).replace(/wi-fi/g, 'wifi');
  const fits = x => x.toLowerCase().split(' ').filter(w => !['security', 'camera', 'cameras', 'for', 'the', 'a'].includes(w)).every(w => hay.includes(w.replace(/s$/, '')));
  const good = [...new Set((board.phrases || []).filter(fits).map(x => x.replace(/\bcameras\b/gi, 'camera')))];
  const lead = good.length ? good[(pinNo - 1) % good.length] : (board.phrases || [board.name])[0];
  const earlier = mine.filter(r => r.title).map(r => r.title + ' / ' + r.description);
  const src = base(photo.url);
  out.push({ json: {
    product_id: id, product_title: p.title, handle: p.handle, brand: p.vendor || '', category: p.category?.name || p.productType || '',
    created: p.createdAt, pin_no: pinNo, pin_kind: kind, board_key: board.key, board_name: board.name, board_id: board.board_id,
    search_phrase: lead, other_phrases: good.filter(x => x !== lead).join(', '), intro, specs,
    source_image: photo.url, photo_url: src + '?width=1024',
    image_url: ['photo', 'photo_2'].includes(kind) ? s.image_template.replace('{url}', encodeURIComponent(src)) : '',
    link: url + (url.includes('?') ? '&' : '?') + s.utm,
    review_quote: kind === 'review' ? review.quote : '', review_rating: kind === 'review' ? Number(review.rating) : null,
    review_author: kind === 'review' ? review.author : '', review_source: kind === 'review' ? review.source : '',
    earlier: earlier.join('\n')
  } });
}
out.sort((a, b) => a.json.pin_no - b.json.pin_no || String(a.json.created).localeCompare(String(b.json.created)));
return out.slice(0, free);
```

## Step 4: Turn the photo into a 2:3 pin image

[Pinterest's product specs](https://help.pinterest.com/en/business/article/pinterest-product-specs) recommend a 2:3 aspect ratio (1000 x 1500 pixels) because wider images can get cut off in feeds. Because [Pinterest applies "AI modified" labels](https://community.pinterest.biz/t/introducing-gen-ai-labels-on-pinterest/30967) to images it detects as AI-generated or edited, and shoppers need to see the physical product as it is, the workflow never alters or outpaints your product photo. (If your catalogue photos need background cleanup before going into Shopify, see the [product images guide](https://www.reganmcgregor.com.au/shopify-product-images/).)

For `photo` and `photo_2` pins, `Pick the next pins` builds `image_url` from `image_template` (`https://wsrv.nl/?url={url}&w=1000&h=1500&fit=contain&cbg=white&output=jpg&q=90`), which uses the free [wsrv.nl image proxy](https://wsrv.nl/docs/) to pad the square photo to 1000 x 1500 with white, and appends `utm` (`utm_source=pinterest&utm_medium=social&utm_campaign=pins`) to `link`.

![The square TC85 KIT product photo next to the padded 1000 x 1500 pin image made by wsrv.nl.](./_attachments/pinterest-automation-shopify/square-photo-vs-padded-pin.png "The square TC85 KIT product photo next to the padded 1000 x 1500 pin image made by wsrv.nl.")

## Step 5: Look at the photo before writing anything

A text model writing alt text from product data alone guesses colours and gets them wrong, such as describing a black camera as white. Looking at the photo with a vision model first gives you accurate alt text and tells the workflow whether the image shows the product, an in-use installation, a retail box, or a spec diagram.

Connect `Pick the next pins` to an [Ollama](https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-langchain.ollama/) node named `Look at the photo` (`retryOnFail: true`, `maxTries: 2`, `waitBetweenTries: 5000`, `onError: continueRegularOutput`):

| Setting | Value |
|---|---|
| Resource | `Image` |
| Operation | `Analyze` |
| Model | `{{ $('Draft settings').first().json.vision_model }}` |
| Input type | `Image URL(s)` |
| URL(s) | `{{ $json.photo_url }}` |
| Options > Temperature | `0.1` |
| Options > Format | `json` |
| Options > Num predict | `200` |

Use this prompt in `Look at the photo`:

```text
Look at this product photo. Reply with JSON only: {"kind": one of "product" (the product on a plain background), "in_use" (installed or in a real setting), "packaging" (a retail box), "diagram" (dimensions, a spec sheet, mostly text), "other"; "alt": one plain sentence under 200 characters describing what is visible: the product type, its colour and shape, and the setting. No brand claims, no sales words.}
```

For the TC85 KIT's first pin, it returned `A white cylindrical security camera and a rectangular black solar panel on a plain white background.` On the fourth pin (`photo_2`), it returned:

```json
{"kind": "product", "alt": "A white cylindrical security camera with an attached solar panel on a plain white background."}
```

Connect `Look at the photo` to a **Code** node named `Read the photo`, which drops any `photo_2` that turns out to be a box or diagram and builds `prompt_input`:

```javascript
// The vision model's answer per photo, plus the input for the writer. A second photo that turns out to be a box,
// a diagram or unreadable is dropped (the product moves on to its next pin next time).
const s = $('Draft settings').first().json;
const picked = $('Pick the next pins').all().map(i => i.json);
const out = [];
$input.all().forEach((it, i) => {
  const p = picked[i]; if (!p) return;
  const r = it.json || {};
  let txt = r.content ?? r.text ?? r.response ?? r.message?.content ?? r.output ?? '';
  if (typeof txt !== 'string') txt = JSON.stringify(txt);
  let v = {};
  try { v = JSON.parse(txt.slice(txt.indexOf('{'), txt.lastIndexOf('}') + 1)); } catch (e) {}
  const kind = ['product', 'in_use', 'packaging', 'diagram', 'other'].includes(v.kind) ? v.kind : '';
  const alt = String(v.alt || '').replace(/\s+/g, ' ').trim().slice(0, 300);
  if (p.pin_kind === 'photo_2' && !['product', 'in_use'].includes(kind)) return;
  const lines = [
    'Product: ' + p.product_title, 'Brand: ' + (p.brand || 'unknown'), 'Category: ' + (p.category || 'unknown'),
    'Search phrase: ' + p.search_phrase, 'Other searches: ' + (p.other_phrases || 'none'),
    'Intro: ' + (p.intro || 'none'), 'Specs: ' + (p.specs || 'none'), 'The photo shows: ' + (alt || 'the product on a white background')
  ];
  if (p.pin_kind === 'review') lines.push('This pin shows this customer review on the image (do not quote it or mention reviews): ' + p.review_quote);
  if (p.earlier) lines.push('Earlier pins for this product. Your title and first sentence must differ from every one of them (keep the search phrase first, change what follows it):\n' + p.earlier);
  out.push({ json: { ...p, photo_kind: kind || null, photo_alt: alt, prompt_input: lines.join('\n') } });
});
return out;
```

## Step 6: Write the pin for Pinterest search

Practical Pinterest SEO comes down to how Pinterest displays and indexes text. According to [Pinterest's product specs](https://help.pinterest.com/en/business/article/pinterest-product-specs), titles can be up to 100 characters, but only the first 40 characters may show in people's feeds, whereas Shopify product titles usually bury the search term behind the brand and model number. Our AI Pinterest pin generator puts the search phrase and a key spec first, with the brand and model last.

Descriptions can be up to 800 characters and don't appear in the home or search feed, but Pinterest's algorithm uses them to determine relevance, whereas hashtags no longer help and copying your product page verbatim repeats storefront boilerplate.

Connect `Read the photo` to a [Basic LLM Chain](https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.chainllm/) node named `Write the pin` (`retryOnFail: true`, `maxTries: 2`, `waitBetweenTries: 3000`, `onError: continueRegularOutput`) with an **Ollama Chat Model** node attached:

| Setting | Value |
|---|---|
| Source for prompt | `Define below` |
| Prompt (user message) | `{{ $json.prompt_input }}` |

Configure `Ollama Chat Model`:

| Setting | Value |
|---|---|
| Model | `{{ $('Draft settings').first().json.chat_model }}` |
| Options > Temperature | `0.4` |
| Options > Num predict | `600` |
| Credential | `Ollama (base URL https://ollama.com and your API key)` |

Set the System message in `Write the pin` (as an expression) to:

```text
You write Pinterest pins for {{ $('Draft settings').first().json.store_name }}, {{ $('Draft settings').first().json.store_description }}. You get one product. Reply with these lines and nothing else:
Pin title: the pin title
Description: the pin description
{{ $json.pin_kind === 'headline' ? 'Headline: the headline for the image\nProduct line: the product line for the image\n' : '' }}
Pin title rules:
- Start with the search phrase, or a close variant that fits this product. Then one key spec. Brand and model last.
- 40 to 90 characters. Never more than 100.
- Capitalise each word.
- If earlier pins are given, never repeat an earlier title.

Description rules:
- Five plain sentences including the closing line, about 450 characters in total, never over 500.
- Sentence one: what it is, with the search phrase, worded differently from the title.
- Sentence two: where it is used and who it suits. Use one of the other searches only if it reads naturally.
- Sentence three: three specs people search for, only if the product data has them.
- Sentence four: two more practical facts from the specs (setup, power, the app, what is in the box).
- End with: {{ $('Draft settings').first().json.closing_line }}
- Each search phrase at most once. No keyword lists, hashtags, emojis, links, phone numbers or prices.
{{ $json.pin_kind === 'headline' ? '\nHeadline rules:\n- A short benefit in plain words, at most 40 characters, from the product data only.\n- No price, no percentages, no claims the data does not support.\nProduct line rules:\n- Brand and model, then two key facts, separated by \" · \". At most 60 characters.\n' : '' }}
All lines:
- Write model numbers as given.
- Only facts in the product data. Never add a spec, a number or a feature, and never call it something it is not.
- Calm and factual. No fear and no hype.
- Never mention the image, photo or picture itself.
- Write in {{ $('Draft settings').first().json.language }}. {{ $('Draft settings').first().json.style_rules }}
- Never use the long dash character.
```

From the Shopify title `TP-Link TC85 KIT 2K QHD Solar-Powered Security Camera Kit`, `Write the pin` produced the 45-character title `Solar Security Camera 2K QHD TP-Link TC85 KIT` and this 371-character description: `This TP-Link TC85 KIT is a solar security camera with a 2K QHD sensor. It is designed for yards, garages or sheds and suits users without power sockets. It features AI detection for people, pets and vehicles, an IP66 weatherproof rating and full colour night vision. The system includes a 10000 mAh battery and uses the Tapo app for setup.` followed by the `closing_line`.

## Step 7: Check every pin before a person sees it

Instead of blocking a draft over a minor slip, `Check the pin` makes safe mechanical fixes (replacing long dashes, stripping hashtags, restoring casing for terms in `keep_terms` like `PoE` and `Wi-Fi`, and ensuring `closing_line` is at the end) and turns everything else into a warning on the Slack card so the reviewer decides. If the model call failed or returned empty text, it outputs nothing so the product is tried again next run.

Connect `Write the pin` to a **Code** node named `Check the pin`:

```javascript
// Parse the model's lines and hold them to the pin rules. Safe fixes are made (dashes, hashtags, casing, the closing line);
// everything else becomes a warning on the card, so the reviewer sees it before approving. A model failure saves nothing.
const s = $('Draft settings').first().json;
const items = $('Read the photo').all().map(i => i.json);
const CLOSE = s.closing_line;
const out = [];
$input.all().forEach((it, i) => {
  const p = items[i]; if (!p) return;
  const raw = String(it.json.text || it.json.output || '');
  if (it.json.error || !raw.trim()) return;   // tried again next run
  const grab = label => { const m = raw.match(new RegExp('^\\s*\\**' + label + '\\**\\s*:\\s*(.+)$', 'im')); return m ? m[1].trim().replace(/^["“]|["”]$/g, '') : ''; };
  const fix = x => x.replace(/—|–/g, ', ').replace(/\s+,/g, ',').replace(/#\w+/g, '').replace(/\s{2,}/g, ' ').trim();
  const caps = x => s.keep_terms.reduce((t, k) => t.replace(new RegExp('\\b' + k.replace(/-/g, '-?') + '\\b', 'gi'), k), x);
  const local = x => /australian|british|new zealand|canadian/i.test(s.language)
    ? x.replace(/\bcolor(s|ed|ful)?\b/gi, (m, e) => (m[0] === 'C' ? 'Colour' : 'colour') + (e || '')).replace(/\bcenter(s|d)?\b/gi, (m, e) => (m[0] === 'C' ? 'Centre' : 'centre') + (e || '')).replace(/\b(meter|meters)\b/gi, m => m.replace(/er/i, 're'))
    : x;
  const clean = x => local(caps(fix(x)));
  let title = clean(grab('Pin title')), description = clean(grab('Description'));
  const headline = clean(grab('Headline')), productLine = clean(grab('Product line'));
  const alt = clean(p.photo_alt || grab('Alt text'));
  if (description && !description.endsWith(CLOSE)) description = description.replace(/[.\s]+$/, '') + '. ' + CLOSE;
  const problems = [];
  if (title.length > 100) problems.push(`Title is ${title.length} characters (100 max).`);
  if (title.length < 25) problems.push('Title is under 25 characters.');
  if (description.length > 600) problems.push(`Description is ${description.length} characters (aim for 300 to 500).`);
  if (description.length < 240) problems.push(`Description is short (${description.length} characters, aim for 300 to 500).`);
  if (p.pin_kind === 'headline') {
    if (!headline) problems.push('No headline for the frame.');
    if (headline.length > 40) problems.push(`Headline is ${headline.length} characters (40 fits the frame).`);
    if (/\$|%|\d+\s*off\b/i.test(headline + ' ' + productLine)) problems.push('Price or discount on the image.');
  }
  const all = [title, description, alt, headline, productLine].join(' ');
  if (/https?:\/\/|www\./i.test(all)) problems.push('Has a web link.');
  if (/\$\s?\d/.test(all)) problems.push('Mentions a price.');
  if (/\p{Extended_Pictographic}/u.test(all)) problems.push('Has an emoji.');
  const banned = s.banned_words ? all.replace(new RegExp(s.store_name, 'g'), '').match(new RegExp(s.banned_words, 'i')) : null;
  if (banned) problems.push(`Uses "${banned[0]}".`);
  const key = p.search_phrase.toLowerCase().split(' ').filter(w => w.length > 2);
  if (key.length && !key.some(w => title.toLowerCase().includes(w.replace(/s$/, '')))) problems.push(`Title doesn't use the search phrase "${p.search_phrase}".`);
  if (p.photo_kind === 'packaging') problems.push('The photo shows the box, not the product. Consider Skip.');
  if (p.earlier && p.earlier.toLowerCase().includes(title.toLowerCase())) problems.push('Same title as an earlier pin.');
  if (/\b(this|the) (image|photo|picture)\b/i.test(description)) problems.push('Talks about the photo instead of the product.');
  out.push({ json: { ...p, title, description, alt_text: alt, headline: p.pin_kind === 'headline' ? headline : '', product_line: p.pin_kind === 'headline' ? productLine : '',
    problems: JSON.stringify(problems) } });
});
return out;
```

In testing on the TC85 KIT's third pin, the model repeated Pin 1's title, and `Check the pin` flagged `Same title as an earlier pin.` on the card. Adding `If earlier pins are given, never repeat an earlier title.` to `Write the pin` solved it, and Pin 4 came out as `Solar Security Camera With AI Detection TP-Link TC85 KIT`.

Connect `Check the pin` to `Save the draft` (`Resource: row`, `Operation: insert`, Data table `pins`, mapping all columns with `status: draft` and `slack_channel: {{ $('Draft settings').first().json.slack_channel }}`), then an **If** node named `Framed pin?` (`{{ ['headline', 'review'].includes($json.pin_kind) }}`). Plain photos (`false`) set `lane: 'card'` and `pin_id: {{ String($json.id) }}` in `Card for the draft` and call `Post the draft card`. Framed pins (`true`) set `lane: 'render'` in `Frame for the draft`, call `Draw the frame`, then set `lane: 'card'` in `Card for a framed draft` and call `Post the framed card`.

## Step 8: Approve, edit or skip in Slack

Every lane draws or updates Slack cards through the **Card** lane. From the `card` output of `Which lane?`, connect `Card settings` (`timezone: UTC`, `workflow_name: {{ $workflow.name }}`) and `Get the pin for the card` (`id eq {{ $('Called by this workflow').first().json.pin_id }}`) to a **Code** node named `Build the card`:

```javascript
// One Slack card for one pin, in whatever state it is in. Every lane redraws the card through here, so it always matches the row.
const s = $('Card settings').first().json;
const r = $input.first().json;
const esc = x => String(x ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
const when = t => t ? DateTime.fromISO(new Date(t).toISOString()).setZone(s.timezone).toFormat('ccc d LLL, h:mm a').replace('AM', 'am').replace('PM', 'pm') : '';
const kinds = { photo: 'photo', headline: 'headline frame', review: 'review frame', photo_2: 'second photo' };
const head = { draft: 'Pin draft', scheduled: 'Scheduled', skipped: 'Skipped', posted: 'Pinned', failed: 'Pin failed' }[r.status] || 'Pin';
const v = String(r.id);
const blocks = [{ type: 'header', text: { type: 'plain_text', text: (head + ': ' + r.product_title).slice(0, 150) } },
  { type: 'context', elements: [{ type: 'mrkdwn', text: `Pin ${r.pin_no} · ${kinds[r.pin_kind] || r.pin_kind}` }] }];
if (r.status === 'skipped') {
  blocks.push({ type: 'context', elements: [{ type: 'mrkdwn', text: 'Skipped by ' + esc(r.decided_by || 'someone') + (Number(r.pin_no) === 1 ? '. This product gets no pins.' : '. The next pin in the sequence comes later.') }, { type: 'mrkdwn', text: s.workflow_name }] });
  return [{ json: { channel: r.slack_channel, ts: r.slack_ts || '', id: r.id, text: 'Skipped: ' + r.product_title, blocks } }];
}
if (r.image_url) blocks.push({ type: 'image', image_url: r.image_url, alt_text: String(r.alt_text || r.product_title).slice(0, 1900) });
else blocks.push({ type: 'section', text: { type: 'mrkdwn', text: ':hourglass: The frame image is not ready yet.' + (r.error ? ' ' + esc(r.error) : '') } });
blocks.push({ type: 'section', text: { type: 'mrkdwn', text: ('*Pin title* (' + String(r.title || '').length + ')\n' + esc(r.title)).slice(0, 2900) } });
blocks.push({ type: 'section', text: { type: 'mrkdwn', text: ('*Description* (' + String(r.description || '').length + ')\n' + esc(r.description)).slice(0, 2900) } });
blocks.push({ type: 'section', text: { type: 'mrkdwn', text: ('*Alt text*\n' + esc(r.alt_text)).slice(0, 2900) } });
if (r.pin_kind === 'headline') blocks.push({ type: 'section', fields: [{ type: 'mrkdwn', text: '*Headline*\n' + esc(r.headline) }, { type: 'mrkdwn', text: '*Product line*\n' + esc(r.product_line) }] });
if (r.pin_kind === 'review') blocks.push({ type: 'section', text: { type: 'mrkdwn', text: '*Review on the image* ' + '★'.repeat(Number(r.review_rating) || 0) + '\n>' + esc(r.review_quote) + '\n' + esc(r.review_author) + (r.review_source === 'sample' ? ' · :warning: *sample review*, swap in a real one before you approve' : r.review_source !== 'own' ? ' · from ' + esc(r.review_source) : '') } });
blocks.push({ type: 'section', fields: [{ type: 'mrkdwn', text: '*Board*\n' + esc(r.board_name) }, { type: 'mrkdwn', text: '*Link*\n<' + r.link + '|' + esc(String(r.link).split('?')[0].replace('https://', '')) + '>' }] });
let problems = []; try { problems = JSON.parse(r.problems || '[]'); } catch (e) {}
if (problems.length && r.status === 'draft') blocks.push({ type: 'section', text: { type: 'mrkdwn', text: ':warning: ' + problems.map(esc).join('\n:warning: ') } });
if (r.status === 'failed' && r.error) blocks.push({ type: 'section', text: { type: 'mrkdwn', text: ':x: ' + esc(r.error).slice(0, 500) } });
const btn = (text, id, style) => Object.assign({ type: 'button', text: { type: 'plain_text', text }, action_id: id, value: v }, style ? { style } : {});
if (r.status === 'draft') blocks.push({ type: 'actions', elements: [btn('Approve', 'pin_approve', 'primary'), btn('Edit', 'pin_edit'), btn('Skip', 'pin_skip', 'danger')] });
if (r.status === 'scheduled') blocks.push({ type: 'actions', elements: [btn('Cancel', 'pin_cancel', 'danger')] });
if (r.status === 'failed') blocks.push({ type: 'actions', elements: [btn('Try again', 'pin_approve', 'primary'), btn('Edit', 'pin_edit'), btn('Skip', 'pin_skip', 'danger')] });
if (r.status === 'posted' && r.pin_url) blocks.push({ type: 'actions', elements: [{ type: 'button', text: { type: 'plain_text', text: 'Open pin' }, url: r.pin_url, action_id: 'pin_open' }] });
const note = {
  draft: 'Approve books the next free slot. Edit changes the words. Skip drops this pin' + (Number(r.pin_no) === 1 ? ' and the product.' : '.'),
  scheduled: ':calendar: Approved by ' + esc(r.decided_by || 'someone') + '. Posts to *' + esc(r.board_name) + '* on ' + when(r.scheduled_for) + '. Cancel takes it back to a draft.',
  posted: ':pushpin: On Pinterest since ' + when(r.posted_at) + '.',
  failed: 'Not posted. Try again books a new slot.'
}[r.status] || '';
blocks.push({ type: 'context', elements: [{ type: 'mrkdwn', text: note }, { type: 'mrkdwn', text: s.workflow_name }] });
return [{ json: { channel: r.slack_channel, ts: r.slack_ts || '', id: r.id, text: head + ': ' + r.product_title, blocks } }];
```

Connect `Build the card` to `Post or update the card` (`Method: POST`, `URL: {{ $json.ts ? 'https://slack.com/api/chat.update' : 'https://slack.com/api/chat.postMessage' }}`, `Authentication: Predefined credential: Slack API`) with this body:

```javascript
{{ JSON.stringify($json.ts ? { channel: $json.channel, ts: $json.ts, text: $json.text, blocks: $json.blocks } : { channel: $json.channel, text: $json.text, blocks: $json.blocks, unfurl_links: false, unfurl_media: false }) }}
```

When `New card?` (`{{ $json.ok === true && !$('Build the card').first().json.ts }}`) is true, `Save where the card is` saves `slack_channel` and `slack_ts` on the row before `Card done`.

In the **Review** lane, Slack sends clicks to `Slack button click` (`POST`, path `pinterest-pin-review`, `Respond: Using Respond to Webhook node`, `Options > Raw Body: on`). Signature verification, [answering within 3 seconds](https://docs.slack.dev/interactivity/handling-user-interaction/), and double-click guards are covered in full in [the Slack approvals guide](https://www.reganmcgregor.com.au/slack-approval-workflow-n8n/). Connect `Slack button click` to `Read the click`:

```javascript
// Slack sends the click as a form field called payload. Keep the raw body for the signature check.
const raw = (await this.helpers.getBinaryDataBuffer(0, 'data')).toString('utf8');
const h = $input.first().json.headers;
if (Math.abs(Date.now() / 1000 - Number(h['x-slack-request-timestamp'])) > 300) throw new Error('Stale request');
const field = raw.split('&').find(kv => kv.startsWith('payload=')) || '';   // no URLSearchParams in the Code node
const b = JSON.parse(decodeURIComponent(field.slice(8).replace(/\+/g, ' ')));
const sig = { base: `v0:${h['x-slack-request-timestamp']}:${raw}`, expected: h['x-slack-signature'] };
const user = b.user?.username || b.user?.name || b.user?.id || 'someone';
if (b.type === 'view_submission') {
  const m = JSON.parse(b.view.private_metadata || '{}');
  const v = b.view.state.values;
  const val = k => v[k]?.[k]?.value ?? null;
  return [{ json: { ...sig, action: 'edit_submit', pin_id: String(m.pin_id), user,
    edit: { title: val('title'), description: val('description'), alt_text: val('alt_text'), headline: val('headline'), product_line: val('product_line') } } }];
}
const a = (b.actions || [])[0] || {};
return [{ json: { ...sig, action: String(a.action_id || '').replace('pin_', ''), pin_id: String(a.value || ''), user,
  trigger_id: b.trigger_id, response_url: b.response_url || '' } }];
```

After `Sign the request` (HMAC-SHA256 of `{{ $json.base }}` into `sig`), `Signature valid?` (`{{ 'v0=' + $json.sig === $json.expected }}`) answers with `Answer Slack` (`No Data`) or `Not from Slack` (401). Then `Review settings` (`zernio_api: https://zernio.com/api/v1`) and `Get the clicked pin` feed `Route the click`:

| Setting | Value |
|---|---|
| approve | `{{ $('Read the click').first().json.action === 'approve' }}` |
| edit | `{{ $('Read the click').first().json.action === 'edit' }}` |
| edit_submit | `{{ $('Read the click').first().json.action === 'edit_submit' }}` |
| skip | `{{ $('Read the click').first().json.action === 'skip' }}` |
| cancel | `{{ $('Read the click').first().json.action === 'cancel' }}` |

On `edit`, `Build the edit modal` builds the [Slack modal payload](https://docs.slack.dev/surfaces/modals/) for `Open the edit modal` (`POST https://slack.com/api/views.open`):

```javascript
// The words of a draft in a modal. A headline pin also gets its headline and product line (saving redraws the frame).
const r = $('Get the clicked pin').first().json;
const c = $('Read the click').first().json;
const input = (key, label, initial, max, multiline) => ({ type: 'input', block_id: key, optional: key === 'alt_text', label: { type: 'plain_text', text: label },
  element: Object.assign({ type: 'plain_text_input', action_id: key, max_length: max, multiline: !!multiline }, initial ? { initial_value: String(initial).slice(0, max) } : {}) });
const editable = ['draft', 'failed'].includes(r.status);
const blocks = [{ type: 'section', text: { type: 'mrkdwn', text: '*' + String(r.product_title || 'Pin').replace(/[<>&]/g, '') + '*' } }];
if (editable) {
  blocks.push(input('title', 'Pin title (search phrase first, 100 max)', r.title, 100), input('description', 'Description', r.description, 800, true), input('alt_text', 'Alt text (what the photo shows)', r.alt_text, 500));
  if (r.pin_kind === 'headline') blocks.push(input('headline', 'Headline on the image (40 fits)', r.headline, 60), input('product_line', 'Product line on the image', r.product_line, 80));
  if (r.pin_kind === 'review') blocks.push({ type: 'context', elements: [{ type: 'mrkdwn', text: 'The review on the image is quoted word for word and can\'t be edited. Skip this pin to drop it.' }] });
} else blocks.push({ type: 'context', elements: [{ type: 'mrkdwn', text: 'This pin is ' + r.status + '. Cancel it on the card first, then edit the draft.' }] });
const view = { type: 'modal', callback_id: 'pin_edit', private_metadata: JSON.stringify({ pin_id: r.id }), title: { type: 'plain_text', text: 'Edit pin' }, close: { type: 'plain_text', text: 'Close' }, blocks };
if (editable) view.submit = { type: 'plain_text', text: 'Save' };
return [{ json: { trigger_id: c.trigger_id, view } }];
```

On `edit_submit`, `Check the edit` validates the changes and flags `redraw` if a headline changed, then `Still a draft?` (`{{ $json.editable }}`) updates the row in `Save the edit`, calls `Draw it again` when `Redraw the frame?` is true, and calls `Redraw the card`:

```javascript
// The edited words, held to the same rules as a new draft. Problems show on the card; nothing is blocked.
const r = $('Get the clicked pin').first().json;
const e = $('Read the click').first().json.edit || {};
const pick = (k, d) => (e[k] == null ? d : String(e[k]).replace(/\s+/g, ' ').trim());
const out = { title: pick('title', r.title), description: pick('description', r.description), alt_text: pick('alt_text', r.alt_text),
  headline: pick('headline', r.headline), product_line: pick('product_line', r.product_line) };
const problems = [];
if (out.title.length > 100) problems.push(`Title is ${out.title.length} characters (100 max).`);
if (out.description.length > 800) problems.push(`Description is ${out.description.length} characters (800 max).`);
if (r.pin_kind === 'headline' && out.headline.length > 40) problems.push(`Headline is ${out.headline.length} characters (40 fits the frame).`);
const all = Object.values(out).join(' ');
if (/https?:\/\/|www\./i.test(all)) problems.push('Has a web link.');
if (/#\w/.test(all)) problems.push('Has a hashtag.');
if (/\$\s?\d/.test(all)) problems.push('Mentions a price.');
const redraw = r.pin_kind === 'headline' && (out.headline !== r.headline || out.product_line !== r.product_line);
return [{ json: { ...out, problems: JSON.stringify(problems), redraw, editable: ['draft', 'failed'].includes(r.status) } }];
```

On `approve`, `Can be booked?` checks `{{ ['draft', 'failed'].includes($json.status) && $json.review_source !== 'sample' }}`, calling `Book it` and `Top up the queue` (`lane: 'top_up'`) when true or replying via `Say why not` when false. On `skip`, `Can be skipped?` (`{{ ['draft', 'failed'].includes($json.status) }}`) marks the row `skipped` in `Mark skipped`, redraws the card, and triggers `Top up after a skip`.

## Step 9: Book the next slot at a steady pace

Posting a sudden burst of pins on a new account or freshly claimed domain looks spammy, and [Pinterest's guide to scheduling tools](https://create.pinterest.com/blog/tools-to-automate-pin-scheduling/) says posting consistently, ideally weekly, is a best practice. While Pinterest's built-in scheduler holds pins up to 30 days ahead, this custom Pinterest scheduler in the **Book** lane lets you schedule Pinterest pins at a rate that scales with your account's age.

Connect the `book` output of `Which lane?` to `Book settings`:

| Setting | Value |
|---|---|
| zernio_api (string) | `https://zernio.com/api/v1` |
| zernio_account_id (string) | `YOUR_ZERNIO_PINTEREST_ACCOUNT_ID` |
| timezone (string) | `UTC` |
| pace (array) | `{{ [ { "from_week": 0, "per_week": 7 }, { "from_week": 4, "per_week": 14 } ] }}` |
| max_per_week (number) | `21` |
| post_from (string) | `07:30` |
| post_until (string) | `21:00` |
| first_slot_after (string) |  |

Connect `Book settings` to `Get the pin to book` (`id eq {{ $('Called by this workflow').first().json.pin_id }}`), then a **Filter** node named `Still bookable?` (`{{ ['draft', 'failed'].includes($json.status) && $json.review_source !== 'sample' }}`) so two simultaneous clicks can't book a pin twice. Next, add `Get booked pins` (fetching rows from `pins` matching `Any condition`: `status eq scheduled` or `status eq posted`) and connect it to `Pick a slot`. It spaces each slot by one week divided by the `pace` for the account's age (7 a week, then 14 from week 4, capped at 21), adds up to 15% jitter, respects `first_slot_after` for testing or launches, and moves overnight times into `post_from` to `post_until`:

```javascript
// The next posting slot: one gap after the latest scheduled or posted pin. The gap is a week divided by the pins a week for
// the account's age at that point (never more than max_per_week), jittered by up to 15%, never sooner than 15 minutes from now,
// and moved into posting hours in your time zone.
const s = $('Book settings').first().json;
const pin = $('Get the pin to book').first().json;
const rows = $input.all().map(i => i.json).filter(r => r.id && String(r.id) !== String(pin.id));
const ms = t => (t ? new Date(t).getTime() : NaN);
const now = Date.now(), WEEK = 7 * 864e5;
const posted = rows.filter(r => r.status === 'posted').map(r => ms(r.posted_at)).filter(x => !isNaN(x));
const taken = rows.filter(r => r.status === 'scheduled').map(r => ms(r.scheduled_for)).filter(x => !isNaN(x)).concat(posted);
const first = posted.length ? Math.min(...posted) : now;
const last = taken.length ? Math.max(...taken) : null;
const week = Math.floor((Math.max(last ?? now, now) - first) / WEEK);
const step = [...s.pace].sort((a, b) => b.from_week - a.from_week).find(p => p.from_week <= week) || { per_week: 3 };
const perWeek = Math.min(Math.max(Number(step.per_week) || 1, 1), s.max_per_week);
const gap = WEEK / perWeek;
let t = last == null ? now + 15 * 6e4 : Math.max(now + 15 * 6e4, last + gap + (Math.random() - 0.5) * 0.3 * gap);
if (s.first_slot_after) t = Math.max(t, ms(s.first_slot_after));
const [fh, fm] = s.post_from.split(':').map(Number), [uh, um] = s.post_until.split(':').map(Number);
let d = DateTime.fromMillis(t).setZone(s.timezone);
const mins = d.hour * 60 + d.minute;
if (mins < fh * 60 + fm || mins > uh * 60 + um) {
  if (mins > uh * 60 + um) d = d.plus({ days: 1 });
  d = d.set({ hour: fh, minute: fm, second: 0, millisecond: 0 }).plus({ minutes: Math.floor(Math.random() * 90) });
}
return [{ json: { slot: d.toUTC().toISO({ suppressMilliseconds: true }), per_week: perWeek, account_week: week } }];
```

## Step 10: Schedule the pin through Zernio

To auto post to Pinterest at the chosen slot, connect `Pick a slot` to an **HTTP Request** node named `Schedule on Pinterest` (`alwaysOutputData: true`, `onError: continueRegularOutput`) that calls [Zernio's posts endpoint](https://docs.zernio.com/platforms/pinterest):

| Setting | Value |
|---|---|
| Method | `POST` |
| URL | `{{ $('Book settings').first().json.zernio_api }}/posts` |
| Authentication | `Generic credential: Header Auth` |
| Options > Timeout (ms) | `20000` |

Use this JSON body expression:

```javascript
{{ (() => { const s = $('Book settings').first().json, r = $('Get the pin to book').first().json; return JSON.stringify({ content: r.description, mediaItems: [ { type: 'image', url: r.image_url, altText: String(r.alt_text || '').slice(0, 500), mimeType: 'image/jpeg' } ], platforms: [ { platform: 'pinterest', accountId: s.zernio_account_id, platformSpecificData: { title: String(r.title || '').slice(0, 100), boardId: r.board_id, link: r.link } } ], scheduledFor: $json.slot, timezone: s.timezone }); })() }}
```

Connect `Schedule on Pinterest` to `Read the booking`:

```javascript
// Zernio's post id, or why it said no.
const z = $input.first().json || {};
const id = z.post?._id || z._id || '';
return [{ json: { id: $('Get the pin to book').first().json.id, post_id: id, status: id ? 'scheduled' : 'failed',
  scheduled_for: id ? $('Pick a slot').first().json.slot : null,
  error: id ? '' : String(z.error?.message || z.error || z.message || JSON.stringify(z)).slice(0, 400) } }];
```

Connect `Read the booking` to `Save the schedule` (updating `status`, `post_id`, `scheduled_for`, `decided_by: {{ $('Called by this workflow').first().json.user }}`, `decided_at: {{ $now.toISO() }}`, and `error`), then `Card after booking` (`lane: 'card'`) and `Show the booking`. With `first_slot_after` set to 10 December in testing, the scheduled card showed `Approved by regan. Posts to Solar & 4G Security Cameras on Thu 10 Dec, 9:00 am. Cancel takes it back to a draft.`

![The scheduled card in Slack: Scheduled, Pin 4 · second photo, a Cancel button and "Approved by regan. Posts to Solar & 4G Security Cameras on Thu 10 Dec, 9:00 am."](./_attachments/pinterest-automation-shopify/scheduled-pin-card.png "The scheduled card in Slack: Scheduled, Pin 4 · second photo, a Cancel button and \"Approved by regan. Posts to Solar & 4G Security Cameras on Thu 10 Dec, 9:00 am.\"")

Clicking **Cancel** on a scheduled card triggers the `cancel` branch in the Review lane: `Is it scheduled?` (`{{ $json.status === 'scheduled' && !!$json.post_id }}`) calls `Delete from Zernio` (`DELETE {{ $('Review settings').first().json.zernio_api }}/posts/{{ $json.post_id }}`), resets the row in `Back to a draft`, and redraws the draft card.

## Step 11: Read back what went live

The **Sync** lane checks Zernio every hour so you know what actually published. Connect `Every hour` (`hoursInterval: 1`, `triggerAtMinute: 7`) and `Check now` to `Sync settings` (`zernio_api: https://zernio.com/api/v1`, `log_channel: #pins-log`), then `Get scheduled pins` (`status eq scheduled`, `Return all: on`, `executeOnce: true`), then a **Filter** node named `Slot passed?`:

```javascript
{{ !!$json.post_id && new Date($json.scheduled_for).getTime() < Date.now() - 120000 }}
```

Connect `Slot passed?` to `Ask Zernio` (`GET {{ $('Sync settings').first().json.zernio_api }}/posts/{{ $json.post_id }}`, `alwaysOutputData: true`, `onError: continueRegularOutput`) and a **Code** node named `Read the result`. If a post was deleted directly in Zernio, Zernio returns a 404 and the pin is marked `failed` so you can click **Try again** on the card:

```javascript
// published -> posted with the pin link; failed or cancelled -> failed with the reason; anything else waits for the next run.
const rows = $('Slot passed?').all().map(i => i.json);
const out = [];
$input.all().forEach((it, i) => {
  const r = rows[i]; if (!r) return;
  if (it.json.error && /\b404\b/.test(String(it.json.error.message || it.json.error))) {   // deleted in Zernio
    out.push({ json: { id: r.id, status: 'failed', pin_url: '', posted_at: null, error: 'Zernio has no post with this id (deleted there?). Try again books a new slot.' } }); return;
  }
  const post = it.json.post || it.json;
  const t = (post.platforms || []).find(p => p.platform === 'pinterest') || {};
  const status = t.status || post.status || '';
  if (status === 'published' || post.status === 'published')
    out.push({ json: { id: r.id, status: 'posted', pin_url: t.platformPostUrl || (t.platformPostId ? 'https://www.pinterest.com/pin/' + t.platformPostId + '/' : ''), posted_at: r.scheduled_for, error: '' } });
  else if (['failed', 'cancelled'].includes(status) || ['failed', 'cancelled'].includes(post.status))
    out.push({ json: { id: r.id, status: 'failed', pin_url: '', posted_at: null, error: String(t.errorMessage || t.error || post.error || status).slice(0, 400) } });
});
return out;
```

From `Read the result`, connect `Save the result` (updating `status`, `pin_url`, `posted_at`, and `error` on `pins`), `Card after sync`, and `Show the result`. In parallel, connect `Read the result` to `Log lines` (`executeOnce: true`) and `Post to the log` (`POST https://slack.com/api/chat.postMessage`):

```javascript
// One line per pin that changed, for the log channel.
const rows = $('Read the result').all().map(i => i.json);
const pins = Object.fromEntries($('Slot passed?').all().map(i => [String(i.json.id), i.json]));
if (!rows.length) return [];
const text = rows.map(r => r.status === 'posted' ? `:pushpin: <${r.pin_url}|${pins[r.id]?.product_title}> on ${pins[r.id]?.board_name}` : `:x: ${pins[r.id]?.product_title}: ${r.error}`).join('\n');
return [{ json: { channel: $('Sync settings').first().json.log_channel, text: 'Pins published\n' + text } }];
```

![The first pin's card after Sync: Pinned, an Open pin button and "On Pinterest since Sun 1 Nov".](./_attachments/pinterest-automation-shopify/pinned-card-after-sync.png "The first pin's card after Sync: Pinned, an Open pin button and \"On Pinterest since Sun 1 Nov\".")

## Step 12: Plan each product's pins

Because a fresh pin needs a new image and many products have only one usable photo, `Pick the next pins` steps each product through `pin_sequence` (`['photo', 'headline', 'review', 'photo_2']`) once its last pin has been up `next_pin_after_days` (7). Sorting by `pin_no` first ensures every product in your catalogue gets its first plain photo pin before any product gets its second pin.

If a product can't make a step (no qualifying review, or no second photo at least `min_photo_px` on its short side), it skips that step cleanly. In testing, the **Ubiquiti UVC-G5-Dome-Ultra-B 2K HD PoE Dome Camera** got its first photo pin and its second headline pin (headline `Compact and tamper-resistant design`, product line `Ubiquiti UVC-G5-Dome-Ultra-B · 2K HD · PoE Power`, and title `Dome Camera 2K HD Ubiquiti UVC-G5-Dome-Ultra-B`, led by its second search phrase "dome camera"), then stopped after two pins because it had one photo and no review. Skipping a product's first pin in Slack stops the product altogether, whereas skipping a later pin moves it on to the next step in the sequence.

## Step 13: Write a headline and draw the frame

Why build an HTML page and screenshot it instead of using n8n's Edit Image node? Edit Image can only use the fonts installed on the n8n host and has no page layout, whereas a 1000 x 1500 HTML page rendered by Firecrawl gives you any Google Font, wrapped text and your brand colours and places the untouched product photo in a rounded panel. No price ever goes on the image because prices change while pins stay up for years.

In the **Frame** lane, add a **Webhook** node named `Frame page` (`GET`, path `pinterest-pin-frame`, `Respond: Using Respond to Webhook node`) and connect `Frame settings`:

| Setting | Value |
|---|---|
| store_name (string) | `Your Store` |
| store_url_text (string) | `your-store.com` |
| logo_url (string) |  |
| font (string) | `Inter` |
| text_colour (string) | `#111827` |
| muted_colour (string) | `#4B5563` |
| accent_colour (string) | `#F59E0B` |
| panel_colour (string) | `#F3F4F6` |

Connect `Get the pin for the frame` (`id eq {{ String($('Frame page').first().json.query.id || '0').replace(/[^0-9]/g, '') }}`) and a **Code** node named `Build the page`, followed by `Send the page` (`Respond With: Text`, `Response Body: {{ $json.html }}`, `Response Code: {{ $json.status }}`, header `content-type: text/html; charset=utf-8`):

```javascript
// The frame as a 1000 x 1500 web page: the real product photo in a panel, then the headline and product line,
// or the review with its stars and who wrote it. Drawn from the saved row only.
const f = $('Frame settings').first().json;
const r = $input.first().json;
const esc = x => String(x ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
if (!r.id) return [{ json: { html: '<!doctype html><title>Not found</title><p>No pin with that id.</p>', status: 404 } }];
const photo = String(r.source_image || '').split('?')[0] + '?width=1400';
let words;
if (r.pin_kind === 'review') {
  const label = r.review_source === 'sample' ? '<span class="tag">Sample review</span>' : (r.review_source && r.review_source !== 'own' ? '<span class="tag">Review from ' + esc(r.review_source) + '</span>' : '');
  words = `<div class="stars">${'★'.repeat(Number(r.review_rating) || 5)}</div><p class="quote">“${esc(r.review_quote)}”</p><p class="who">${esc(r.review_author)}${label}</p>`;
} else {
  const size = String(r.headline || '').length > 28 ? 72 : 88;
  words = `<h1 style="font-size:${size}px">${esc(r.headline)}</h1><p class="line">${esc(r.product_line)}</p>`;
}
const brand = f.logo_url ? `<img src="${esc(f.logo_url)}" alt="${esc(f.store_name)}">` : `<span>${esc(f.store_name)}</span>`;
const html = `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=1000">
<link href="https://fonts.googleapis.com/css2?family=${encodeURIComponent(f.font)}:wght@400;600;800&display=swap" rel="stylesheet">
<style>*{box-sizing:border-box;margin:0}html,body{width:1000px;height:1500px;background:#fff}
body{font-family:'${f.font}',sans-serif;color:${f.text_colour};display:flex;flex-direction:column;padding:56px}
.photo{flex:0 0 860px;background:${f.panel_colour};border-radius:32px;display:flex;align-items:center;justify-content:center;overflow:hidden}
.photo img{max-width:90%;max-height:90%;object-fit:contain;mix-blend-mode:multiply}
.words{flex:1;display:flex;flex-direction:column;justify-content:center;padding:36px 12px 12px}
h1{line-height:1.02;font-weight:800;letter-spacing:-0.02em}.line{margin-top:22px;font-size:32px;color:${f.muted_colour}}
.stars{color:${f.accent_colour};font-size:54px;letter-spacing:6px}.quote{margin-top:16px;font-size:48px;line-height:1.2;font-weight:600}
.who{margin-top:22px;font-size:28px;color:${f.muted_colour};display:flex;align-items:center;gap:14px}
.tag{padding:4px 16px;border-radius:999px;background:${f.panel_colour};font-size:22px}
.foot{display:flex;justify-content:space-between;align-items:center;font-size:30px;font-weight:600}.foot img{height:56px}.foot .url{color:${f.muted_colour};font-weight:400}
</style></head><body><div class="photo"><img src="${esc(photo)}" alt="${esc(r.alt_text)}"></div>
<div class="words">${words}</div><div class="foot">${brand}<span class="url">${esc(f.store_url_text)}</span></div></body></html>`;
return [{ json: { html, status: 200 } }];
```

In the **Render** lane, because [Firecrawl's screenshot URLs](https://docs.firecrawl.dev/features/scrape) expire after 24 hours, the workflow converts the screenshot into a JPEG via wsrv.nl and stores it in Shopify Files using [`fileCreate`](https://shopify.dev/docs/api/admin-graphql/2026-10/mutations/fileCreate). Connect `Render settings` (`store_domain`, `frame_page_url`, and `jpeg_template: https://wsrv.nl/{name}.jpg?url={url}&output=jpg&q=90`) and `Get the pin to draw` to `Screenshot the frame` (`POST https://api.firecrawl.dev/v2/scrape`, Header Auth, timeout `90000`):

```javascript
{{ JSON.stringify({ url: $('Render settings').first().json.frame_page_url + '?id=' + $json.id + '&v=' + Date.now(), waitFor: 2500, formats: [ { type: 'screenshot', fullPage: false, quality: 95, viewport: { width: 1000, height: 1500 } } ] }) }}
```

Connect `Screenshot the frame` to `Name the file`:

```javascript
// The screenshot as a JPEG named after the pin, by way of wsrv.nl. A failed screenshot is passed on with its error.
const s = $('Render settings').first().json;
const r = $('Get the pin to draw').first().json;
const shot = $input.first().json?.data?.screenshot || '';
const name = ('pin-' + String(r.product_title || 'pin').toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 60) + '-' + r.id + '-' + Date.now()).replace(/-+/g, '-');
return [{ json: { id: r.id, old_file_id: r.shopify_file_id || '', alt: r.alt_text || '',
  source: shot ? s.jpeg_template.replace('{name}', name).replace('{url}', encodeURIComponent(shot)) : '',
  error: shot ? '' : 'Firecrawl: ' + String($input.first().json?.error?.message || $input.first().json?.error || 'no screenshot').slice(0, 200) } }];
```

Connect `Get Shopify token for Render`, then `Keep it in Shopify` (`POST` to GraphQL):

```javascript
{{ JSON.stringify({ query: 'mutation Keep($files: [FileCreateInput!]!) { fileCreate(files: $files) { files { id fileStatus } userErrors { field message } } }', variables: { files: $('Name the file').first().json.source ? [ { originalSource: $('Name the file').first().json.source, contentType: 'IMAGE', alt: String($('Name the file').first().json.alt).slice(0, 500) } ] : [] } }) }}
```

Wait 15 seconds in `Let Shopify process`, then fetch the processed URL in `Read the file`:

```javascript
{{ JSON.stringify({ query: 'query File($id: ID!) { node(id: $id) { ... on MediaImage { id fileStatus image { url } } } }', variables: { id: $('Keep it in Shopify').first().json.data?.fileCreate?.files?.[0]?.id || 'gid://shopify/MediaImage/0' } }) }}
```

Connect `Read the file` to `Collect`:

```javascript
// The frame's lasting URL, or why there isn't one.
const n = $('Name the file').first().json;
const made = $('Keep it in Shopify').first().json;
const f = $input.first().json?.data?.node || {};
const id = made?.data?.fileCreate?.files?.[0]?.id || '';
const url = f.fileStatus === 'READY' ? (f.image?.url || '') : '';
const error = n.error || (!id ? 'Shopify: ' + JSON.stringify(made?.data?.fileCreate?.userErrors || made?.errors || 'no file').slice(0, 200) : (!url ? 'Shopify is still processing the image (' + (f.fileStatus || 'unknown') + '). Edit and save to draw it again.' : ''));
return [{ json: { id: n.id, file_id: id || n.old_file_id, image_url: url, error, old_file_id: url && n.old_file_id && n.old_file_id !== id ? n.old_file_id : '' } }];
```

After `Save the frame`, if `Old frame to delete?` (`{{ !!$('Collect').first().json.old_file_id }}`) is true, `Delete the old frame` runs `fileDelete` before `Frame done`:

```javascript
{{ JSON.stringify({ query: 'mutation Drop($ids: [ID!]!) { fileDelete(fileIds: $ids) { deletedFileIds userErrors { field message } } }', variables: { ids: [ $('Collect').first().json.old_file_id ] } }) }}
```

For the TC85 KIT's second pin, the model wrote `Clear footage without a power socket` / `TP-Link TC85 KIT · 2K QHD · Solar Powered`. Editing it in Slack to `Solar powered. No wiring.` / `TP-Link TC85 KIT · 2K QHD · colour night vision` redrew the frame and deleted the old Shopify file.

## Step 14: Put a real review on the pin

Customer reviews make strong third pins when handled properly. This is not legal advice, so check the rules where you sell, including the [FTC's rule on consumer reviews and testimonials](https://www.federalregister.gov/documents/2024/08/22/2024-18519/trade-regulation-rule-on-the-use-of-consumer-reviews-and-testimonials) and the [ACCC's guidance on online product reviews](https://www.accc.gov.au/media-release/accc-releases-guidance-about-online-product-reviews):

- **Quote real reviews word for word:** `Pick the next pins` selects the quote directly from `pin_reviews` (`rating >= review_min_rating`, `quote.length <= review_max_chars`, unused on earlier pins, verified first), and the model never touches or trims the quote.
- **Label the source when imported:** Reviews from your own store use `source: 'own'`. If you import reviews from elsewhere, `Build the page` displays `Review from <source>` next to the author's name.

In the template, the TC85 KIT's third pin rendered with five stars, `“Set it up on the shed in twenty minutes. The solar panel keeps it charged, and the picture at night is better than I expected.”`, and `Sample Customer` with a `Sample review` tag, while `Can be booked?` refused to book it until you swap in real reviews with `source: 'own'`.

## What it costs

The cost follows your posting pace rather than the size of your catalogue: one pin a day is about 30 pins a month and two a day is about 60, whatever your product count. Each pin makes two short model calls (vision and text), and framed pins (about two in four) cost one Firecrawl credit each. On [n8n Cloud](https://n8n.io/pricing/), the Card, Render, and Book lanes run as sub-workflows, which [don't count toward plan limits](https://docs.n8n.io/flow-logic/subworkflows/); what counts is the daily Draft run (30), the hourly Sync (720, or 240 if run every 3 hours), one execution per Slack click, and one per frame render.

| Item | 1 pin a day (about 30 a month) | 2 a day (about 60) | 3 a day (about 90, the cap) |
|---|---|---|---|
| n8n self-hosted | Free | Free | Free |
| n8n Cloud | Starter, €20 a month (about 830 executions) | Starter (about 900) | Starter (about 980) |
| Zernio (one Pinterest account) | Free | Free | Free |
| Ollama Cloud | About 60 short calls; pay per token, or a small part of Pro's US$60 of usage | About 120 calls | About 180 calls |
| Firecrawl | About 15 frames, inside the free 1,000 credits | About 30 | About 45 |
| Slack, Shopify Admin API, wsrv.nl | Free | Free | Free |

By comparison, a Pinterest scheduler app such as [Tailwind's Pin Scheduling & Creation plan](https://www.tailwindapp.com/pricing) costs US$17.99 a month billed annually (US$29.99 monthly) for 300 scheduled pins (checked November 2026), and you still write the copy and make the images yourself. To lower usage further, reduce `pace`, run Sync every 3 hours, lower `max_waiting`, or use a local vision model.

## Common mistakes

### Generating or editing the product image
AI-generated backgrounds or edits trigger [Pinterest's "AI modified" label](https://community.pinterest.biz/t/introducing-gen-ai-labels-on-pinterest/30967) and misrepresent the physical item. Always pad or frame the real product photo untouched.

### Posting a burst on a new account
Publishing dozens of pins at once on a new domain looks like spam. Let `Pick a slot` space pins across the week according to `pace`.

### Booking the same pin twice
Double clicks or two reviewers acting at once can double-book a post without state checks. `Still bookable?` ensures only a `draft` or `failed` pin is ever scheduled.

### Writing for the product page instead of Pinterest search
Copied descriptions, SKU-first titles, keyword lists, and hashtags hurt search reach. Put the search phrase in the first 40 characters of the title and write plain sentences.

### Expecting Trial-access API pins to be public
Pins created on Pinterest API Trial access are visible only to the creator until Standard access is approved. Schedule through Zernio until your own app is approved.

### Pinning accessories and box shots
Mounting brackets and cardboard box photos waste slots and get ignored in feeds. Filter accessories with `skip_words` and skip drafts when `Check the pin` warns about `packaging`.

### Leaving off UTM parameters
Without UTM tags on `link`, Pinterest traffic blends into unattributed referrals in analytics.

### Trimming or rewording a review
Editing a customer quote can change its meaning and breach review rules. Filter for short quotes under `review_max_chars` and quote them word for word.

### Showing an imported review as your own customer's
Leaving the source off a third-party review misleads shoppers. Set `source` in `pin_reviews` so the frame shows `Review from <source>`.

### Putting a price on the image
Prices change while pins stay live for years, so keep prices and discounts off the frame.

## Make it your own

### Post through Pinterest's API directly
Once your developer app has Standard access on the Pinterest API, replace `Schedule on Pinterest` and `Ask Zernio` with direct calls to `POST /v5/pins` and `GET /v5/pins/{id}` in your n8n Pinterest workflow. Pinterest's API posts straight away rather than booking ahead, so call it from Sync when a slot comes due.

### Export to Pinterest's bulk upload CSV
If you want no posting API at all, write approved rows to a CSV for [Pinterest bulk upload](https://create.pinterest.com/blog/tools-to-automate-pin-scheduling/), which accepts up to 200 pins at once.

### Pull reviews from your review app's API
Sync verified reviews automatically from Judge.me, Loox, or Okendo into `pin_reviews` with `source: 'own'`.

### Write pins for guides and blog posts
Point `Get products` at your Shopify blog articles to turn buying guides into headline pins.

### Cross-post to Instagram
Adapt the Zernio payload and Shopify Files frames for Instagram (covered in the Instagram version).

### Add offer or gift guide frames
Create seasonal frame variants using evergreen wording that stays true after the holiday ends.

## FAQ

### Is it allowed to automate Pinterest?
Yes, Pinterest supports scheduling through its own Pin scheduler, CSV bulk upload, RSS auto-publish, and partner tools. This workflow has a person approve every pin in Slack, keeps the real product photo, and spaces posts through Zernio.

### How many pins should I post a day?
Pinterest says posting consistently, ideally weekly, is a best practice. Starting at one pin a day (7 a week) and stepping up to two a day (14 a week) from week four builds steady momentum.

### Do I still need the Pinterest app for Shopify?
You don't need it for this template, but it's worth keeping: the Pinterest app for Shopify syncs your product catalogue for rich pins and shopping ads, which is a separate job from publishing fresh pins to your boards. Running both together gives you automatic price metadata on the pins this workflow schedules.

### Can the AI make the pin images?
No, Pinterest detects and labels AI-modified images, and buyers need to see the real product you ship. The workflow pads your original photo to 2:3 for the first pin and places the untouched photo in an HTML frame for later pins.

### Can I put customer reviews on my pins?
Yes, provided the review is genuine, quoted word for word with its star rating, and never rewritten or trimmed by AI. If the review came from outside your store, the frame must show where it came from.

### Does it work for stores outside electronics?
Yes, just update `boards`, `skip_words`, `keep_terms`, and `store_description` in `Draft settings` to match your products. The vision check, search-first titles, and HTML frames work for any store with clear product photos.

## Next steps

Run Setup to create the tables and list your boards, paste your board IDs into `Draft settings`, and open the `Frame page` URL in your browser to set your brand colours. Approve your first three cards in Slack and watch the slots fill.

<TemplateCallout
  repo="https://github.com/reganmcgregor/n8n-ecommerce-templates/tree/main/pinterest-automation"
>

- Drafts Pinterest product pins from your Shopify catalogue using a vision model for accurate alt text and a chat model for search-focused titles and descriptions.
- Pads your real product photo to 2:3 for the first pin, then renders HTML headline and customer review frames for later pins without AI-modifying the photo.
- Sends every draft to Slack to approve, edit or skip, then paces approved pins into posting hours through Zernio and logs live Pinterest URLs back to your table.

</TemplateCallout>
