Automate Unsplash to Pinterest with n8n: A Story of One Marketer’s Breakthrough

On a rainy Tuesday afternoon, Mia stared at her Pinterest dashboard and sighed.

She was the solo marketer at a growing design studio, and Pinterest was supposed to be their secret traffic engine. The problem was simple and painful: every day, she hunted for fresh images on Unsplash, copied links, wrote new descriptions, tried to remember keywords, logged everything in a spreadsheet, then finally created pins. By the time she finished, she had barely enough energy left to think about strategy.

“There has to be a better way,” she muttered, watching her cursor blink over yet another blank pin description field.

That was the moment she decided to automate the entire Unsplash to Pinterest pipeline. Her search led her to an n8n workflow template that promised exactly what she needed: a way to capture Unsplash images and metadata, enrich them with AI, and send everything into a structured system that could power Pinterest posts automatically.

This is the story of how Mia went from manual chaos to a scalable, intelligent n8n workflow that used a webhook, Cohere embeddings, Supabase vector storage, and a RAG agent to generate Pinterest-ready content with an audit log and error alerts.

The Problem: Great Images, No Time, and Zero Context

Mia’s workflow looked familiar to many marketers:

• Browse Unsplash for visual inspiration
• Copy image URLs, titles, and tags into a spreadsheet
• Write new Pinterest descriptions from scratch
• Try to remember SEO keywords and brand tone each time
• Hope nothing got lost between tools and tabs

Her pins were beautiful, but the process was slow and brittle. There was no audit log, no consistent metadata, and no way to reuse context from past images. If she forgot why she chose a particular image or how it performed, she had nothing structured to look back at.

What she really needed was:

• A way to store and retrieve contextual metadata for each image
• Automatic generation of pin titles and descriptions with an LLM
• A reliable log of everything that happened, plus alerts when something failed

When she found an n8n template that connected a Webhook trigger to a Retrieval-Augmented Generation (RAG) agent, using Cohere embeddings and Supabase vector storage, it felt like the missing piece. The template promised to take raw Unsplash metadata, turn it into vectors, use a vector store to retrieve context, and let an AI agent generate Pinterest-friendly copy, all logged in Google Sheets with Slack alerts on failure.

The Plan: Build an Intelligent Unsplash to Pinterest Pipeline

Mia did not want another fragile script. She wanted a robust automation that could grow with her content library. The n8n workflow template she discovered was built around a clear pattern:

Webhook → Text Splitter → Embeddings → Supabase Vector Store → RAG Agent → Google Sheets Log → Slack Alert

Instead of manually juggling tools, this pipeline would:

• Accept a POST request with Unsplash image data
• Split and embed the text using Cohere
• Store vectors in Supabase for semantic search
• Use a Vector Tool and RAG Agent to generate descriptions
• Log everything to Google Sheets
• Ping Slack if anything went wrong

She decided to set up the exact template and adapt it to her studio’s needs.

Setting the Stage: Credentials and Checklist

Before touching any nodes in n8n, Mia grabbed a notebook and listed what she would need. The template’s setup checklist guided her:

1. Create API keys for:
   • Cohere (for embeddings)
   • OpenAI (for the chat model)
   • Supabase (for vector storage)
   • Google Sheets (for logging)
   • Slack (for alerts)
2. Provision a Supabase project with pgvector enabled
3. Create a table and index named unsplash_to_pinterest
4. Secure the webhook endpoint with a secret token or IP allowlist
5. Plan a small test payload before connecting live Unsplash traffic

Once credentials were ready and Supabase was configured, she imported the n8n template and stepped into the flow that would change her daily routine.

Rising Action: Walking Through the n8n Workflow as a Story

The Entry Point: Webhook Trigger

In Mia’s new world, nothing started with copy-paste. It started with a simple HTTP request.

At the top of the workflow sat the Webhook Trigger node. Its path was set to /unsplash-to-pinterest, and it was configured to accept POST requests. This was where her Unsplash integration, or any scheduled job, would send image metadata.

She tightened security by using a signing secret and an IP allowlist so only trusted services could call this endpoint. That way, every time a new Unsplash image was selected, a structured payload could kick off the whole automation.

Her test payload looked like this:

{  "image_id": "abc123",  "title": "Sunset over coastal cliffs",  "description": "A dramatic sunset over rocky cliffs with warm orange light.",  "tags": ["sunset", "coast", "landscape"],  "unsplash_url": "https://unsplash.com/photos/abc123"
}

With a single POST, the story of each image began.

Breaking the Text Down: Text Splitter

Next in the chain was the Text Splitter. Mia had never thought about chunking text before, but embeddings work best when content fits within model limits.

The template came configured with:

• chunkSize = 400
• chunkOverlap = 40

This meant long descriptions or aggregated metadata would be split into overlapping segments, perfect for downstream embedding. For her typical Unsplash descriptions, these defaults worked well, but she knew she could adjust them later if her metadata grew longer or shorter.

Giving Text a Shape: Embeddings with Cohere

The story continued in the Embeddings (Cohere) node. Here, the text chunks from the splitter were turned into vector representations that captured semantic meaning.

The node used the embed-english-v3.0 model. Mia added her Cohere API key in the node credentials and watched as each chunk of description, title, and tags was transformed into a set of numbers that could later power semantic search.

These embeddings would become the backbone of her intelligent Pinterest descriptions, allowing the system to find related content and context as her library grew.

Where Memory Lives: Supabase Insert and Supabase Query

Now that the text had been embedded, Mia needed a place to store it. The template used Supabase as a vector store, and this was where her new content memory would live.

The Supabase Insert node wrote the newly generated vectors into a table and index named unsplash_to_pinterest. Each row included:

• The vector itself
• Associated metadata such as image_id, title, description, tags, and URL

Before this worked, she had to ensure:

• The Supabase project had the pgvector extension enabled
• The table schema matched what the node expected to insert

Later in the flow, the Supabase Query node came into play. It would read from the same unsplash_to_pinterest index and retrieve vectors similar to the current image. At query time, it pulled back the most relevant context so the RAG agent could write smarter, more connected descriptions.

Giving the Agent a Tool: Vector Tool

To make this vector store useful to the AI agent, the workflow introduced the Vector Tool node. This node exposed the Supabase index to the RAG agent as a tool named “Supabase – Vector context”.

In practice, this meant the RAG agent could call out to Supabase during generation, fetch related images and metadata, and weave that context into the final Pinterest description or title. Instead of writing in isolation, the agent could “look up” similar content and stay consistent with Mia’s visual themes and language.

Keeping the Conversation Coherent: Window Memory

As Mia explored the workflow, she noticed the Window Memory node. Its job was subtle but important: it stored recent conversation history and key context across the workflow run.

When the RAG agent and the chat model interacted, this memory helped them maintain state. If the same image or related images were processed in sequence, the agent could keep track of what had already been said, which improved the quality and consistency of generated descriptions.

The Turning Point: Chat Model and RAG Agent in Action

The real magic happened when the workflow reached the Chat Model (OpenAI) and the RAG Agent.

The Chat Model node pointed to OpenAI for natural language generation. Mia added her OpenAI API key and configured the model to write in her brand’s tone: friendly, descriptive, and SEO-aware.

The RAG Agent then became the orchestrator. It combined three critical ingredients:

• The LLM from the Chat Model node
• The vector store, accessed through the Vector Tool
• The Window Memory context

When an Unsplash image payload arrived, the agent would:

1. Use the vector tool to retrieve relevant context from Supabase
2. Read the current image’s metadata and any similar past entries
3. Generate a final output, such as:
   • An SEO-friendly Pinterest description
   • A compelling pin title

For the sample “Sunset over coastal cliffs” payload, the agent could produce a description that referenced the dramatic light, coastal landscape, and related sunset imagery already in the vector store. The result felt thoughtful rather than generic.

Proof and Accountability: Append Sheet with Google Sheets

Before this workflow, Mia’s “audit log” was a messy spreadsheet that she updated by hand. The template gave her a structured alternative.

The Append Sheet (Google Sheets) node logged each RAG agent output into a Google Sheet. Every time an image was processed, the workflow appended a new row to the Log sheet.

The mapping included a Status column that contained the agent’s text and any other fields she wanted to track. Over time, this sheet became:

• An audit log of all generated Pinterest content
• A review queue for manual approval, when needed
• A source of data for analytics, such as engagement or scheduled post IDs

She later extended the sheet with extra columns for performance metrics and scheduling information, turning it into a lightweight content operations hub.

When Things Go Wrong: Slack Alert as a Safety Net

Mia knew that no automation is perfect. API limits, schema changes, or model issues could break the flow. The template anticipated this with a dedicated safety net.

If an error occurred in the RAG Agent, the workflow’s onError branch triggered the Slack Alert node. This node posted a message to a channel like #alerts, including details about the failure so her team could react quickly.

Instead of silently failing and leaving gaps in her content schedule, the workflow raised a hand in Slack and asked for help.

First Test: From Sample Payload to Pinterest-Ready Copy

With all nodes configured, Mia ran her first full test. She used curl to send the sample payload to the webhook:

{  "image_id": "abc123",  "title": "Sunset over coastal cliffs",  "description": "A dramatic sunset over rocky cliffs with warm orange light.",  "tags": ["sunset", "coast", "landscape"],  "unsplash_url": "https://unsplash.com/photos/abc123"
}

She watched the workflow in n8n:

• The Webhook Trigger fired successfully
• The Text Splitter chunked the description
• Cohere generated embeddings for each chunk
• Supabase Insert stored the vectors in unsplash_to_pinterest
• Supabase Query retrieved relevant context
• The Vector Tool provided that context to the RAG agent
• The Chat Model and RAG Agent produced a Pinterest-friendly description
• Append Sheet logged the output in Google Sheets

Nothing broke, and no Slack alerts arrived. The result was a polished description Mia could paste straight into Pinterest or send to a scheduling tool.

Monitoring, Scaling, and Staying Sane

Once the initial excitement wore off, Mia started thinking about the future. What would happen when she processed hundreds of images or when the team relied on this workflow daily?

She followed a few best practices from the template:

• Test with tools like curl or Postman to validate end-to-end behavior before going live
• Monitor n8n logs and cross check them with the Google Sheets log for consistency
• Handle rate limits by:
  • Batching inserts to Supabase
  • Throttling requests to Cohere and OpenAI
• Consider caching frequent queries if similar images were processed often
• Prune old vector data if the Supabase storage grew too large or if outdated content was no longer needed

With these safeguards, the workflow could grow from a single marketer’s helper into a core part of the studio’s content engine.

Security and Privacy in Mia’s New Automation

As her team grew, Mia became more careful about security. The workflow handled API keys and user-submitted content, so she followed the template’s recommendations:

• Stored all API keys using n8n credentials or environment variables, never in plain text
• Ensured the webhook endpoint was protected with a secret token or IP allowlist
• Verified that they had the right to republish any images and complied with Unsplash license terms

This gave her confidence that the automation would not introduce unexpected risks as more people on the team used it.

Customizing the Workflow to Fit Her Brand

Once the core pipeline was stable, Mia started tailoring the template to her studio’s needs.

Auto-posting to Pinterest

Instead of stopping at Google Sheets, she experimented with adding a Pinterest node or calling the Pinterest API directly. The goal was to create pins programmatically using:

• The generated description
• The title
• The Unsplash image URL

This turned the workflow into a near end-to-end automation, from raw Unsplash data to live Pinterest content.

Moderation and Brand Voice

For some campaigns, she wanted a human in the loop. She added:

• An AI moderation step to filter sensitive or off-brand content
• A manual approval stage that used the Google Sheets log as a review queue

This kept the brand voice consistent and gave her creative team a chance to tweak copy before it went live.

Analytics and Reporting

Finally, she extended the Google Sheets log with new columns for:

• Engagement metrics
• Scheduled post IDs

<