<!-- BusyBot node reference — https://busybot.net/tools/bannerbear/ -->

> Node: Bannerbear (`bannerbear`) · Action (binary) · v1
> Category: Marketing · Credentials: Bannerbear API (`bannerbearApi`)
> Updated: 2026-08-16

# Bannerbear

> Generate images from Bannerbear templates

## Overview

Bannerbear renders images from templates you design once and reuse with different content. This tool creates an image from a template, overriding named layers with your own text, colours, backgrounds and image URLs; fetches a previously generated image by ID; and reads template metadata, including the layers each template exposes. Rendering is asynchronous — by default the node returns as soon as the job is accepted, but it can also wait for the finished image and attach the rendered file to the item as binary data.

**Category:** Marketing  
**Tool Name:** `bannerbear`  
**Version:** 1

**Appearance:** Icon: `lucide-Image` | Color: `#FF6F00`

## Node Type

**Action (Binary)** — handles file/binary data operations

## Input / Output

| Direction | Port(s) |
|-----------|--------|
| Input | `Input` |
| Output | `Output`, `Error` |

## Credentials

This tool requires **Bannerbear API** credentials.
See the [Credentials Guide](https://busybot.net/credentials/bannerbear-api/) for setup instructions.

### Resources

| Resource | Value |
|----------|-------|
| Image | `image` |
| Template | `template` |

### Operations

**Image**

| Operation | Value | Description |
|-----------|-------|-------------|
| Create | `create` | Create an image from a template |
| Get | `get` | Get an image by ID |

**Template**

| Operation | Value | Description |
|-----------|-------|-------------|
| Get | `get` | Get a template |
| Get Many | `getAll` | Get all templates |

### Parameters

`Template: Get Many` takes no parameters of its own — see All Operations.

#### Image: Create

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Template ID | `string` | Yes | — | The UID of the Bannerbear template to use for image generation. Find this in your Bannerbear project dashboard. Supports expressions like {{ $json.templateId }}. |
| Modifications | `fixedCollection` | No | `{}` | Layer modifications to apply to the template. |
| — Modification | | | | One entry per template layer you want to change. |
| — — Name | `string` | No | — | The name of the template layer to modify. Get available layer names from the template details. |
| — — Text | `string` | No | — | Replacement text for the layer. Supports expressions like {{ $json.headline }}. |
| — — Color | `string` | No | — | Color hex value for the object (e.g., #FF0000). |
| — — Background | `string` | No | — | Background color hex value for text layers. |
| — — Image URL | `string` | No | — | Public URL of a replacement image for image layers. |
| Additional Fields | `collection` | No | `{}` | Additional options for image creation. |
| — Metadata | `string` | No | — | Arbitrary metadata string for tracking (e.g., a record ID from your database). |
| — Wait for Image | `boolean` | No | `false` | Whether to poll until the image is fully rendered before returning. If enabled, the rendered image is downloaded as binary data. |
| — Wait Max Tries | `number` | No | `3` | Maximum number of polling attempts (every 2 seconds) before failing. _(shown when Wait for Image is `true`)_ |
| — Webhook URL | `string` | No | — | A URL to receive a POST callback with the image object when rendering is complete. |
| Binary Property | `string` | No | `data` | Name of the binary property to store the downloaded image in. Names are case-sensitive — see the upstream node's Binary Data panel for the exact names to use. |

#### Image: Get

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Image ID | `string` | Yes | — | The unique identifier (UID) of the image to retrieve. Supports expressions like {{ $json.imageId }}. |

#### Template: Get

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Template ID | `string` | Yes | — | The unique identifier (UID) of the template to retrieve. Supports expressions like {{ $json.templateId }}. |

#### All Operations

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| Max Concurrency | `number` | No | `5` | Maximum number of items to process concurrently. Lower values recommended when using waitForImage to avoid rate limits. |

## Output Data

One output item per input item — no operation on this node fans out, including `Template: Get Many`. The API response is **merged onto the input item JSON**, so the returned fields sit alongside whatever the item already carried.

| Resource / operation | Merged onto the item |
|----------------------|----------------------|
| `image` / `create` | The image object Bannerbear returned, including its `uid`, its `status`, and — once rendering has finished — `image_url` |
| `image` / `get` | The image object for the requested UID, in the same shape |
| `template` / `get` | The template record, including the modifiable layers it exposes |
| `template` / `getAll` | `templates` — the full array of templates on one item. Bannerbear returns them in a single response, so use a Split Out node on `templates` if you want one item per template |

**Binary.** Binary already on the input item is always carried through. With **Wait for Image** on, the node polls until the image reports `completed`, then downloads the rendered file and attaches it under the property named in **Binary Property** (default `data`), merged with the item's existing binary. The stored file name is taken from the image URL when it has one, otherwise `bannerbear_image.png`. With **Wait for Image** off, the create call returns immediately with a pending status and no file is downloaded — the image is still rendering, and you retrieve it later with `Image: Get` or via a webhook.

Reference the result downstream by expression, e.g. `{{ $json.uid }}` or `{{ $json.image_url }}`.

## Usage Examples

- Generate a social media image from a Bannerbear template
- Create a product banner with dynamic text overlays
- List all available Bannerbear templates
- Get a previously generated image by ID

## Example Configuration

Render an image and wait for the finished file, storing it on a named binary property:

```json
{
  "type": "bannerbear",
  "parameters": {
    "resource": "image",
    "operation": "create",
    "templateId": "A89wZ2bmN6YjRaELJ9",
    "modificationsUi": {
      "modificationsValues": [
        { "name": "title", "text": "{{ $json.title }}" },
        { "name": "subtitle", "text": "{{ $json.subtitle }}", "color": "#FF6B35" },
        { "name": "logo", "imageUrl": "{{ $json.logoUrl }}" }
      ]
    },
    "additionalFields": {
      "waitForImage": true,
      "waitForImageMaxTries": 5,
      "metadata": "{{ $json.recordId }}"
    },
    "binaryPropertyName": "generatedImage"
  }
}
```

Fire the render and move on, letting a webhook tell you when it is ready:

```json
{
  "type": "bannerbear",
  "parameters": {
    "resource": "image",
    "operation": "create",
    "templateId": "A89wZ2bmN6YjRaELJ9",
    "modificationsUi": {
      "modificationsValues": [
        { "name": "title", "text": "{{ $json.title }}" }
      ]
    },
    "additionalFields": {
      "webhookUrl": "https://example.com/hooks/bannerbear"
    }
  }
}
```

Fetch a previously generated image by its UID:

```json
{
  "type": "bannerbear",
  "parameters": {
    "resource": "image",
    "operation": "get",
    "imageId": "{{ $json.uid }}"
  }
}
```

Read one template's details to discover its layer names:

```json
{
  "type": "bannerbear",
  "parameters": {
    "resource": "template",
    "operation": "get",
    "templateId": "A89wZ2bmN6YjRaELJ9"
  }
}
```

List every template in the project:

```json
{
  "type": "bannerbear",
  "parameters": {
    "resource": "template",
    "operation": "getAll"
  }
}
```

### Error Handling

| Mode | Behavior |
|------|----------|
| **stop** | Halts workflow on first error |
| **continue** | Skips failed items, passes successful ones through |
| **errorPort** | Routes failed items to Error output port |

## Tips

Generate images from Bannerbear templates with dynamic text/image modifications, with optional binary download of the rendered image.

### Notes

- **Modification names must match template layer names exactly.** Run `Template: Get` first to list the layers a template exposes; a modification whose Name matches nothing is silently ignored by Bannerbear and you get the unmodified template back.
- **Set only the fields that apply to a layer.** Text layers take Text, Color and Background; image layers take Image URL. Empty fields are dropped before the request, so leaving them blank is safe.
- **Image URL must be publicly reachable.** Bannerbear fetches the replacement image itself; a signed or private URL that has expired renders as a blank layer.
- **Rendering is asynchronous.** Without **Wait for Image**, the create call returns a pending image with a `uid` and no `image_url`. Turn the option on when the next node needs the file itself, or supply **Webhook URL** and pick the result up in a separate workflow.
- **Waiting costs time and rate limit.** Polling runs every two seconds up to **Wait Max Tries**; a complex template that takes longer than that fails the item. Raise the tries rather than the concurrency, and keep **Max Concurrency** low while waiting.
- **Metadata comes back on the image object,** so it is a convenient place to stash the record ID that triggered the render and correlate the webhook callback later.