# n8n Marketing Automation Tutorial: Generate & Post Visuals

> Generate marketing images and videos from templates, then auto-post to Instagram, LinkedIn. Step-by-step n8n marketing automation tutorial + free workflow template

- **Author**: Rishi Mohan
- **Published**: 2026-06-03
- **Tags**: n8n, Automation, Marketing, Social Media, Tutorials
- **Read time**: 10 min read
- **URL**: https://orshot.com/blog/n8n-marketing-automation-tutorial

---

**TL;DR:** Most n8n marketing automation guides stop at "send a Slack message." This one goes end-to-end: a new row of data → a branded **image** _and_ a **video** → auto-posted to **Instagram and LinkedIn**. n8n moves the data; [Orshot](https://orshot.com/) handles both the creation _and_ the posting — so one tool does the work of a design app, a video editor, and a social scheduler.

**[📥 Download the n8n workflow (JSON)](https://orshot.com/blog/n8n-marketing-automation-orshot.json "target=_blank")** — import it into n8n and follow along.

## What we're building

Take a travel company. Every time they add a new tour, they want a polished Instagram post **and** a short Reel-style video out the door, on both Instagram and LinkedIn, without anyone opening a design tool. Same pattern works for a SaaS shipping a feature, a store launching a product, or an events team announcing a webinar — anything where _new data_ should become _on-brand content_.

The pipeline, at a glance:

![Pipeline: new tour data, then Orshot renders an image and video, then publishes to Instagram and LinkedIn](https://orshot.com/blog/n8n-marketing-guide/pipeline-diagram.png)

Here's the actual output from one row of tour data — the **same template** produces both the static post and the animated version:

<div
  style=}
>
  <img
    src="/blog/n8n-marketing-guide/sample-render-image.png"
    alt="Branded tour post (PNG) generated from one row of data"
    style=}
  />
  <video
    autoPlay
    loop
    muted
    playsInline
    controls
    style=}
  >
    <source
      src="/blog/n8n-marketing-guide/sample-render-reel.mp4"
      type="video/mp4"
    />
  </video>
</div>

_Left: the static post (PNG). Right: the same template as an animated Reel (MP4)._

## Why n8n needs Orshot for the visual

n8n is excellent at moving data — triggers, HTTP calls, branching, hundreds of app integrations. What it can't do is _design_. You can generate copy with an LLM node in one line, but a branded graphic — right font, exact headline, your colors, a logo that doesn't drift — is where most marketing workflows give up and post plain text.

You design the visual **once** in an Orshot template, mark the parts that change as parameters, and every run fills them in. The text stays real text, the colors stay your hex codes, and the output is pixel-identical every time. Then the same API call can **publish** it — so the picture never touches a human's desktop. That's the whole idea behind [social media content automation](https://orshot.com/solutions/social-media-content-automation): one design, every format, posted automatically.

| Node                  | What it does                                                                |
| --------------------- | --------------------------------------------------------------------------- |
| **Trigger**           | Fires on new data (we use a manual click; swap for Sheets/Webhook/Schedule) |
| **New Tour Data**     | Maps your row to the template's parameters + the caption                    |
| **Render Post Image** | `POST` to Orshot → branded PNG                                              |
| **Render Reel Video** | Same call, `format: mp4` → animated MP4                                     |
| **Publish**           | Adds a `publish` object → posts to Instagram + LinkedIn                     |

## What you'll need

- An [Orshot account](https://orshot.com/pricing "target=_blank") and an API key (free tier = 60 renders).
- An n8n instance (Cloud or self-hosted).
- A template to render — we'll use a ready-made travel template (ID `12278`), but any of the [1,000+ library templates](https://orshot.com/templates) or your own design works.
- Connected [social accounts](https://orshot.com/features/social-publishing) in Orshot (Instagram + LinkedIn) for the publish step.

## Step 1 — One template, image _and_ video

In the Orshot Studio editor, the template is built once: a headline, a subheadline, three photo slots, a location tag, a handle, and a footer line. The layers that change per post are marked as **parameters** — everything else stays locked, so your brand can't drift.

![The travel template in the Orshot Studio editor, with an animation timeline](https://orshot.com/blog/n8n-marketing-guide/01-studio-editor.png)

This template is already animated, which is the key part: because the design has motion, the **exact same template** renders a static PNG _or_ an MP4 — you only change the output format. No separate video tool, no re-design.

Open **Automate** on any template to see its parameters and the integration options. Note the **Template ID** and the parameter ids (`headline_top`, `location_text`, `hero_image`, …) — your n8n data maps onto these.

![The Integrate Template panel showing the template ID, n8n integration, and parameters](https://orshot.com/blog/n8n-marketing-guide/02-integrate-template-params.png)

We're using a travel template here, but the workflow is template-agnostic — swap in whatever your marketing calls for: ad creatives, product banners, quote cards, OG images, multi-slide carousels, certificates. You don't have to design from scratch either: pick from [1,000+ ready-made templates](https://orshot.com/templates) in the library, generate one from a prompt with the [AI Template Generator](https://orshot.com/features/ai-template-generator), or import an existing design from Canva or Figma. Parameterize it once and the same n8n flow drives it.

## Step 2 — Grab your API key

In the Orshot dashboard, go to **API Keys** and copy one (or create a new one). You'll paste it into n8n in the next step.

![The Orshot API Keys page](https://orshot.com/blog/n8n-marketing-guide/04-api-keys.png)

## Step 3 — Import the workflow into n8n

The fastest way to start: [download the workflow JSON](https://orshot.com/blog/n8n-marketing-automation-orshot.json "target=_blank") and import it (**⋯ menu → Import from file**). You'll get the full pipeline wired up:

![The full n8n workflow: trigger, data, render image, render video, publish](https://orshot.com/blog/n8n-marketing-guide/06-n8n-workflow-overview.png)

Two nodes do the setup work:

- **Run on a new tour** — a Manual Trigger so you can test with one click. In production, swap it for a **Google Sheets Trigger** (new row), a **Webhook** (form/CRM), or a **Schedule** node. Anything that can send data works; the rest of the flow doesn't change.
- **New Tour Data** — an _Edit Fields_ node holding one tour's data. Each field name matches a template parameter, plus a `caption` and `booking_url` for publishing.

![The Edit Fields node mapping tour data to template parameters](https://orshot.com/blog/n8n-marketing-guide/07-node-new-tour-data.png)

In production you'd delete these literal values and map columns from your trigger instead — e.g. `}`.

## Step 4 — Render the branded image

The render node is a plain **HTTP Request**: `POST` to `https://api.orshot.com/v1/studio/render`, your key in the `Authorization` header, and a JSON body that maps the tour data onto the template.

![The HTTP Request node configured to render from Orshot](https://orshot.com/blog/n8n-marketing-guide/08-node-render-image.png)

The JSON body — note how each value pulls from the **New Tour Data** node:```json
{
  "templateId": 12278,
  "modifications": {
    "kicker_text": "{{ $json.category }}",
    "headline_top": "{{ $json.headline_top }}",
    "headline_bottom": "{{ $json.headline_bottom }}",
    "subheadline": "{{ $json.subheadline }}",
    "hero_image": "{{ $json.hero_image }}",
    "photo_two": "{{ $json.photo_two }}",
    "photo_three": "{{ $json.photo_three }}",
    "location_text": "{{ $json.location_text }}",
    "brand_handle": "{{ $json.brand_handle }}",
    "footer_note": "{{ $json.footer_note }}"
  },
  "response": { "type": "url", "format": "png" }
}
```Prefer the terminal first? It's the same call:```bash
curl -X POST https://api.orshot.com/v1/studio/render \
  -H "Authorization: Bearer YOUR_ORSHOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "templateId": 12278,
    "modifications": {
      "headline_top": "Aegean",
      "headline_bottom": "Sailing",
      "location_text": "SANTORINI, GREECE",
      "footer_note": "From $1,299 · Book now"
    },
    "response": { "type": "url", "format": "png" }
  }'
```You get back a hosted PNG URL you can hand to the next node, store, or attach to a Slack message.

Prefer not to hand-roll the HTTP node? Orshot ships a [verified n8n node](https://orshot.com/integrations) — search "Orshot" in the node panel, connect your API key, pick the template, and the parameter fields populate automatically. Orshot even spells out the steps in-app:

![Orshot's in-app n8n integration steps](https://orshot.com/blog/n8n-marketing-guide/03-n8n-integration-steps.png)

## Step 5 — Render the video from the same data

This is the part most tutorials skip. The reel is the **same node, same body — one field changes**:```json
"response": { "type": "url", "format": "mp4" }
```That's it. Because the template is animated, Orshot returns a ready-to-post MP4. Want to trim it or set the frame rate? Add `videoOptions`:```json
{
  "templateId": 12278,
  "modifications": { "headline_top": "Aegean", "headline_bottom": "Sailing" },
  "response": { "type": "url", "format": "mp4" },
  "videoOptions": { "duration": 6, "fps": 30 }
}
```One template, two formats, zero extra design work — exactly the kind of [automated image (and video) generation](https://orshot.com/solutions/automated-image-generation) that's painful to do by hand and trivial to do on a schedule.

## Step 6 — Publish to Instagram and LinkedIn

Here's where Orshot replaces a second tool. Instead of piping the file into Buffer or a separate scheduler, you add a `publish` object to the **same render call** and Orshot posts it for you.

First, connect your accounts in Orshot under **Social Accounts** and note each account's **ID** — that's what the workflow targets.

![Connected social accounts in Orshot with their account IDs](https://orshot.com/blog/n8n-marketing-guide/05-social-accounts.png)

Then the publish node's body is your render body plus a `publish` block:```json
{
  "templateId": 12278,
  "modifications": { "headline_top": "Aegean", "headline_bottom": "Sailing" },
  "response": { "type": "url", "format": "png" },
  "publish": {
    "accounts": [19, 15],
    "content": "{{ $json.caption }}",
    "platformOptions": {
      "15": { "firstComment": "Book this tour 👉 {{ $json.booking_url }}" }
    }
  }
}
```- `accounts` — the IDs from your Social Accounts page (here `19` = Instagram, `15` = LinkedIn). **Replace these with your own.**
- `content` — the caption used across platforms.
- `platformOptions` — per-platform tweaks. LinkedIn gets the booking link as a first comment (keeps the caption clean and the link out of the post body). Instagram uses the default caption with hashtags.

You can also `isDraft: true` to stage posts, or add a `schedule` block to post later — see the [Publish docs](https://orshot.com/docs/publish/introduction).

> **Safety note:** In the downloadable workflow, the **Publish** node is **deactivated** on purpose — so importing and testing never posts to your accounts by accident. n8n confirms it: _"This node is disabled, and will simply pass the input through."_ Enable it only when your account IDs and caption are set.

![The Publish node, deactivated by default so nothing posts during testing](https://orshot.com/blog/n8n-marketing-guide/10-node-publish-disabled.png)

## Make it run on its own

Right now you click **Execute workflow** to test. To make it autonomous, replace the Manual Trigger:

- **Google Sheets Trigger** — a content calendar; each new row ships a post.
- **Webhook** — your CRM or a form (Tally, Typeform) fires a render the moment someone submits.
- **Schedule** — a daily/weekly drop from a data source.

The render and publish nodes don't change — only how the flow starts.

## Doing it in bulk

Rendering one post per execution is the n8n-native way and keeps things simple. But if you need to fan out — a back-catalog of 200 tours, localized variants per market — call Orshot's **batch render** with an array of modification sets and get them all back in one request instead of 200 executions. For volume work that's faster and cheaper than looping in the workflow.

## What it costs

n8n's self-hosted edition is free (you pay for the server); n8n Cloud starts around \$24/mo at the time of writing. Orshot's free tier is **60 renders** with every feature unlocked, and paid plans start at **\$30/mo for 3,000 renders** — each rendered image _or_ video counts as a render. Publishing is an add-on at **\$12/mo per connected account**, with unlimited posts.

[**Try Orshot Free →**](https://orshot.com/pricing "target=_blank") **(60 renders, no card needed)**

**Q: What is n8n marketing automation?**

It's using n8n — an open-source workflow automation tool — to run marketing tasks without manual work: pulling data, generating content, and publishing it. n8n handles the data flow and triggers; pair it with Orshot when the workflow needs branded images or videos and direct social posting, which n8n can't do on its own.

**Q: Can n8n generate images and videos?**

Not by itself. n8n moves data and calls APIs, but it can't design a branded graphic. Connect it to Orshot: you design a template once, mark the dynamic parts as parameters, and every workflow run renders a pixel-accurate image or video. The same animated template outputs both a PNG and an MP4 — you only change the format field.

**Q: How do I auto-post to Instagram and LinkedIn from n8n?**

Add a publish object to your Orshot render call with the account IDs from your Social Accounts page. Orshot renders the image or video and posts it to the chosen platforms in one step — with per-platform captions, drafts, or scheduling. No separate scheduler like Buffer needed.

**Q: Do I need to code to use this workflow?**

No. Download the JSON, import it into n8n, paste your Orshot API key, and replace the example data and account IDs. The only 'code' is a JSON body in an HTTP Request node, which is included and explained above.

**Q: Will importing the workflow post to my socials by accident?**

No. The Publish node ships deactivated, so importing and testing only renders — it never posts. You enable it deliberately once your account IDs and caption are set.

**Q: What does it cost to start?**

n8n self-hosted is free; n8n Cloud starts around $24/mo. Orshot is free for 60 renders with no card, then $30/mo for 3,000 renders. Publishing is a $12/mo per-account add-on with unlimited posts.

> **Bottom line:** n8n handles the data; Orshot handles the design _and_ the posting. Parameterize one template, import the workflow, point any trigger at it, and your marketing visuals — image and video — generate and publish themselves.