---
title: "Stock photo title, description and keywords from a webhook"
kind: "Kit"
category: "Marketing & SEO"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/27308330-d920-4dc3-a127-1da35ff20843"
updated: "2026-11-12"
---

# Stock photo title, description and keywords from a webhook

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow with a webhook. Post it a picture, as a public address or as base64, and gpt-4o-mini writes a stock marketplace title, a description and up to 40 keywords. The reply holds them with a ready CSV row.

Stock photo title, description and keywords from a webhook is an n8n workflow in the Marketing \& SEO category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow writes the metadata a stock marketplace asks for. Something posts it a picture, either as a public address or as base64 text. `gpt-4o-mini` looks at the picture and returns a title, a short description and 20 to 40 keywords. The workflow cleans the answer, builds a CSV row from it and replies to the same call. Seven nodes do the work, with no form and no sticky notes.

### Who it suits

Stock photographers and illustrators, small agencies that upload for them, and teams with a library of images to describe. A script or an upload tool can call the webhook for each file. Skip it if your marketplace needs categories, model releases or its own fixed keyword list.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Stock photography | Contributors | Call the webhook for each new photo and paste the CSV rows into an upload sheet | A contributor posts a harbor photo and gets a title, a description and a keyword list to paste. |
| Illustration and design | Designers who sell their work | Describe each new artwork before listing it | An illustrator sends a flat vector of a mountain trail and edits the title it returns. |
| Image libraries | Marketing teams | Add searchable titles and keywords to a folder of old photos | A team loops a script over a folder and keeps every reply in one CSV. |
| Agencies | Production assistants | Prepare a client’s batch for a marketplace | An assistant runs a client’s fifty product shots through it before the upload. |

You need little n8n: import a file, paste one key and send a test request. Anything that can post JSON can call it.

### Where to use it

Any n8n with an address the caller can reach will run it. n8n Cloud does, and so does your own server on the internet.

- n8n Cloud: import the file into a new workflow there
- Your own n8n server: the same file and steps
- A script or an upload tool: post each picture to the production address and read the reply
- A spreadsheet: add a node after \`Build CSV Row\` to append the row to a sheet

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. One OpenAI key is all it needs.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| OpenAI | An API key that can use \`gpt-4o-mini\` |
| A caller | A script or a tool that posts JSON to the webhook |
| A picture | A public address, or base64 text |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Open `Vision LLM`. In its Authorization header, replace `<YOUR_OPENAI_API_KEY>` with your key. The brackets go, and Bearer and its space stay.
3. Save, open `Webhook` and copy its test address. It ends in `stock-image-meta`.
4. Press Listen for test event and post a body such as the one below.
5. Press Publish when the reply looks right and use the production address.

```json
{ "imageUrl": "https://example.com/photo.jpg" }
```

### How to use it

Post a JSON body with `imageUrl` for a public address, or `imageBase64` for the picture itself. The call stays open while OpenAI looks at the picture, and the reply comes back in the same call. Use the reply’s `csv_row` for a sheet and the other fields for anything else.

What to change for a different result

| To change | Where |
| --- | --- |
| What the metadata asks for | The two messages in \`Build Vision Request\` |
| The model | \`model\` in \`Build Vision Request\` |
| The answer’s length | \`max\_tokens\` in the same node |
| The CSV’s separator and columns | \`Build CSV Row\` |
| The address people post to | \`path\` in \`Webhook\` |

### Example

A contributor posts the address of a photo of fishing boats in a harbor at dawn.

The reply is a JSON array with one object. It holds a `title` of fewer than 12 words and a `description` of two or three sentences about the boats and the light. A lowercase `keywords` list follows, with its `keyword_count`. `csv` carries the same three fields as a header and one row. Read the keywords before you upload them, since a model can name something the photo does not show.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. This one is a straight line: take the picture, ask OpenAI, clean the answer, build the CSV, reply. Send one picture first and read the reply.

**For experts.** The OpenAI call is a plain HTTP request with the key in a header, and the reply sends every incoming item back as JSON.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`Parse Input\` | Reads the picture from \`imageUrl\`, \`image\_url\`, \`image\` or \`imageBase64\` | Bare base64 is wrapped as a \`data:\` link of type \`image/jpeg\` |
| \`Vision LLM\` | Posts the request to chat completions | The timeout is 120 seconds |
| \`Parse Metadata\` | Removes code fences and reads the JSON | It stops the run when the description or the keywords are missing |
| \`Respond to Webhook\` | Replies with all incoming items | Its response text is not used with this setting |

### Good to know

The webhook is open, the reply is an array, and the model has a shutdown date.

- Models: OpenAI’s deprecations page, read on 12 November 2026, lists the dated \`gpt-4o-mini\` version for shutdown on 14 January 2027, with \`gpt-6-luna\` as the replacement. It does not list the bare name \`gpt-4o-mini\`, which Mindket’s copy keeps. Check that a new model accepts \`max\_tokens\` and \`temperature\` before you swap it in
- Reply shape: the response node answers with all incoming items, so the reply is a JSON array with one object. The \`responseBody\` text in that node, which would add a \`success\` flag, is not used
- Keyword count: the 20 to 40 is only a request in the prompt, and \`keyword\_count\` reports what came back
- Pictures: an address must be open to OpenAI, so a link behind a login fails. Bare base64 is always labeled \`image/jpeg\`
- Open webhook: anyone with the address can start a call on your key, so turn on the webhook’s authentication or keep the address private
- Billing: OpenAI bills one \`gpt-4o-mini\` call for each picture
- Your data: every picture goes to OpenAI
- Keys: the OpenAI key sits in a header, so take it out before you share the workflow

## README

````markdown
# Stock photo title, description and keywords from a webhook

An n8n workflow with a webhook. You post it a picture, either as a public address or as base64, and `gpt-4o-mini`
looks at the picture and writes a title, a description and a list of keywords for a stock marketplace. The reply holds
them as fields and as a ready CSV row.

## What is inside

- `workflow.json`: the workflow as n8n exports it, 7 nodes and no sticky notes. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

The Authorization header of `Vision LLM` held the text `Bearer YOUR_OPENAI_API_KEY`. It now reads
`Bearer <YOUR_OPENAI_API_KEY>`, so a key pasted over the brackets is easy to spot. The rest is as the original copy had it.

## Before you start

- An n8n instance with an address the sender can reach. n8n Cloud works, and so does your own server on the internet.
- An OpenAI API key that can use `gpt-4o-mini`.
- Pictures to send: public links, or the files themselves as text.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Open `Vision LLM`. In its Authorization header, replace `<YOUR_OPENAI_API_KEY>` with your key. The brackets go. Keep
   the word Bearer and the space after it.
3. Save, then open `Webhook` and copy its test address. It ends in `stock-image-meta`.
4. Press Listen for test event, then post a picture to that address. This body works:

```json
{ "imageUrl": "https://example.com/photo.jpg" }
```

5. Press Publish when the reply looks right. Your production address is the same path under `/webhook/`.

## How a run goes

1. `Webhook` takes a POST on the path `stock-image-meta`. It waits for a node to answer, so the sender gets the result
   in the same call.
2. `Parse Input` reads `imageUrl`, `image_url` or `image` from the body. It also accepts `imageBase64`, and when that
   text has no `data:` start it adds `data:image/jpeg;base64,`. With no picture it stops with an error that says so.
3. `Build Vision Request` writes the request for OpenAI's chat completions API. The system message makes the model a
   stock photo metadata writer. The user message asks for raw JSON with a `title` under 12 words, a 2 to 3 sentence
   `description` and 20 to 40 lowercase `keywords`. It sets `gpt-4o-mini`, a temperature of 0.3 and 800 tokens.
4. `Vision LLM` posts that body to `https://api.openai.com/v1/chat/completions` with a 120 second timeout.
5. `Parse Metadata` takes the model's text, removes code fences, reads the JSON, and falls back to the first `{...}`
   block if that fails. A missing title becomes `Untitled`. A missing description or an empty keyword list stops the run.
6. `Build CSV Row` doubles any quote marks, joins the keywords with a semicolon and a space, and builds `csv_row` and a
   `csv` text that starts with the header `"title","description","keywords"`.
7. `Respond to Webhook` answers with every incoming item as JSON.

## Change the look

- The metadata's rules: the two messages in `Build Vision Request`. Change the title length, the keyword count or the
  marketplace it names.
- The model: `model` in the same node. A newer model may refuse `max_tokens` or `temperature`, so check that it accepts
  both before you swap it in.
- The answer's length: `max_tokens` in that node.
- The CSV: `Build CSV Row`. Change its separator to a comma if your marketplace wants one.
- The address people post to: `path` in `Webhook`.

## Good to know

- OpenAI's deprecations page, read on 12 November 2026, lists the dated `gpt-4o-mini` version for shutdown on 14
  January 2027, with `gpt-6-luna` as the replacement. It does not list the bare name `gpt-4o-mini`, which this copy
  keeps.
- `Respond to Webhook` is set to answer with all incoming items, so the reply is a JSON array with one object holding
  `title`, `description`, `keywords`, `keyword_count`, `csv_row` and `csv`. The `responseBody` text in that node, which
  would add a `success` flag, is not used with this setting.
- The 20 to 40 keywords are only a request in the prompt. Nothing counts them, and `keyword_count` reports what came
  back.
- An address in `imageUrl` must be reachable by OpenAI, so a link behind a login or on a private network fails. A bare
  base64 text is always labelled `image/jpeg`, whatever the file is.
- The webhook has no authentication. Anyone with its address can start a call that spends your key, so turn on the
  webhook's own authentication or keep the address private.
- One `gpt-4o-mini` call runs for each picture, and every picture goes to OpenAI.
- The key sits in a header field, not in a credential, so it travels with any export. Take it out before you share the
  workflow.
````

## What is in it

3 files, 12 KB, downloaded as a zip.

```text
NOTICE.md  592 B
README.md  5 KB
workflow.json  7 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 7 steps, starting when its webhook is called
- AI: No step calls an AI model
- Sign-ins: Signs in to: OpenAI
- API keys: No API key is left in the file; 1 blank in it for your own key
- Step types: Mindket’s checker reads all 4 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/27308330-d920-4dc3-a127-1da35ff20843)
- [Its page on Mindket](https://mindket.com/p/27308330-d920-4dc3-a127-1da35ff20843)
