Media automation · replacement recipe

Go from Bannerbear to your own fixed-template image API

The job: Fixed-template image generation (Template rendering, Variable text/images, Batch generation, API output). Pick where you are today and where you want to land; the move below follows your pick.

From · what you pay for now
Bannerbear
Bannerbear Scale · $149/mo
Year one+$748modeled
To · your pickBest fit
Your own fixed-template image API
Built by your coding agent · $20/mo + 0.5 h upkeep a month
Change where you land

The money

$149/mo today $20/mo

Bannerbear Scale

Year one, net+$748
Pays back in4.8 months

Modeled from public list prices, with your time at $50 an hour. Show the math

Does it do the job? 3 of 4 covered, 1 not checked

  • Template rendering built to your spec
  • Variable text/images built to your spec
  • Batch generation not checked
  • API output built to your spec

The work

Setup
About 8 h + $100
Upkeep
0.5 h a month
Watch out
No video, AI media operations, visual template designer or all integrations.

Make the move in four steps

  1. Export from Bannerbear

    Generated images and videos (job outputs)

    Export steps

  2. Build it

    Download SPEC.md for your coding agent: what to build, what's out of scope, and the acceptance tests to pass.

    Get the build spec

  3. Switch links and integrations

    Point links, embeds and integrations at Your own fixed-template image API, then send a test through every one.

  4. Cancel Bannerbear

    Turn off renewal before your renewal date, once the new setup works. Access runs until: The end of the billing period (Cancel at end of billing period)….

    How to cancel Bannerbear
Get the build specHow to cancel Bannerbear
Modeled, not measured. Savings use public prices and planning assumptions: the bill you stop paying, minus the new tool, your upkeep time and your setup time at $50/hour, over the first 12 months. Paths marked Tested by Stackcut were run end to end by us on our own products. They're our tests, not customer results. Check the must-haves in each recipe before you switch.

The whole recipe: 3 ways out, best first

What you use

  • Template rendering
  • Variable text/images
  • Batch generation
  • API output

Not covered

  • Video generation
  • AI media credits
  • Visual template designer
  • Every integration

Check before switching

  • Limited known templates
  • Fonts and source assets licensed
  • Image-only workload
  • Benchmark actual CPU and storage costs

Agents: get_recipe("image-templates") on the Stackcut MCP server.

3 ways out, best first

Replace with AIReplace with AI: fixed-template image APISaves $748 in year one
$149/mo today → $20/mo + 0.5 h upkeep · setup 8 h + $100 · then $1,248/yr · payback 4.8 mo
Up to 10,000 static images/month across five templates
Covers 100% of the core features
How we got this
You pay now: Bannerbear Scaleflat price$149/mo
New cost: Replace with AI: fixed-template image APIhosting and API costs (modeled)$20/mo
Your upkeep time0.5 h/mo × $50/h$25/mo
Difference each month$149 − $20 − $25+$104/mo
Over 12 months+$104 × 12+$1,248
Setup, once8 h × $50/h + $100 one-time−$500
Year one+$1,248 − $500+$748
  • Not counting your time (14 h in year one): saves $1,448 in year one.

Year one = 12 × (what you pay now − the new cost − upkeep) − setup, with your time at $50/hour. Prices are public list prices; hours are Stackcut’s planning estimates. Price it for your team

Sources: bannerbear.com
Agent skillAgent skill: render template images from dataTested by Stackcut · Works, with caveatsSaves $213 in year one
$49/mo today → $0/mo + 0.5 h upkeep · setup 1.5 h · then $288/yr · payback 3.1 mo
1 person making link previews, social posts or certificates from a spreadsheet or CMS export on their own computer (tested: 50 images in about 4 seconds). The skill renders and checks every PNG; a person reviews them and posts or sends them.
Covers 75% of the core features (not: API output (no hosted API, image URLs, CDN or webhooks), Instant URLs (images made on the fly from a link), Fetching images from web addresses (download them first), App integrations (Zapier, Airtable, forms))
Renders and checks PNGs on your computer from HTML templates kept in the skill folder; nothing is hosted and nothing is posted or sent without a person. Assumes you already pay for an agent that runs skills and can run commands; that agent's cost isn't counted. Needs Node and Playwright's free Chromium (a one-time download). Setup (rebuilding your templates in HTML, which your agent can draft) and upkeep are estimates of your own time. The $49 baseline is Bannerbear Automate, 1,000 API credits a month (checked 2026-09-29). If anything calls Bannerbear's API or uses its image URLs, this path doesn't replace it.
How we got this
You pay now: Bannerbear Automateflat price$49/mo
New cost: Agent skill: render template images from dataruns in the agent you already pay for$0/mo
Your upkeep time0.5 h/mo × $50/h$25/mo
Difference each month$49 − $0 − $25+$24/mo
Over 12 months+$24 × 12+$288
Setup, once1.5 h × $50/h−$75
Year one+$288 − $75+$213
  • Not counting your time (7.5 h in year one): saves $588 in year one.

Year one = 12 × (what you pay now − the new cost − upkeep) − setup, with your time at $50/hour. Prices are public list prices; hours are Stackcut’s planning estimates. Price it for your team

  • Tested by Stackcut: 14 of 14 test cases passed a strict grading pass in round 2 (10 of 14 in round 1), with a checker that opened every PNG; an independent round (a fresh agent ran every case, a separate agent graded it) passed 13 of 14. our test
  • No image credits or plan: 50 link previews rendered in about 4 seconds on an ordinary machine. our test
  • Every image is checked before you see it: exact size, text that doesn't fit or is cut, images that didn't load, characters with no font, brand-font fallback and safe file names. our test
  • No new subscription if you already pay for an agent that runs skills: a skill is a folder of files the agent loads. agentskills.io
  • No API output: no hosted image URLs, CDN, webhooks or images made on the fly from a link. our test
  • It doesn't fetch images from web addresses: those rows get a fallback image and a warning until someone downloads the files. our test
  • Templates are HTML/CSS, not a visual editor, so each Bannerbear template has to be rebuilt (an agent can draft them; a person approves the design). our test
  • Results depend on the fonts on the machine that renders: on a bare server, Japanese text had no font (caught and not delivered). our test
  • If you need an API, Placid lists a REST API, a URL API and integrations on every plan. placid.app
  • In an independent round (a fresh agent ran every case, a separate agent graded it) 13 of 14 passed: every image was right, but one reply left out a font warning the render report had. Read the report. our test
Step-by-step: set up, move your data, check, roll back · about 1.5 h (estimate)

Keep your templates as HTML files in a skill folder; your agent renders each batch on your computer, checks every image and hands you the PNGs to review and post.

Budget about an hour and a half to rebuild your templates in HTML (your agent can draft them) and install Playwright's Chromium once. Building and testing the skill took Stackcut about 53 minutes of agent time; each test round took 3 to 6 minutes.

Before you start

  1. Download every generated image you still use. Cancelling a Bannerbear plan deletes its projects, templates and images, so links to Bannerbear-hosted images will stop working. bannerbear.com
  2. Check that nothing calls Bannerbear's API (site code, automations, forms): this skill has no API to point them at.
  3. List each template with its size, fonts and fields; they become the HTML templates and references/templates.md.

Set up

  1. Use the Agent Skills layout: SKILL.md (steps, output format, Never list), references/ for templates, brand and checks, assets/ for the HTML templates and scripts/ for the renderer. agentskills.io
  2. Install Node and Playwright's Chromium once (npm install playwright && npx playwright install chromium); after that, rendering works offline.
  3. Rebuild each template with text boxes that have a fixed height or max-height and don't hide overflow, a minimum size for each text field, and data-keep-clear on rules or logos that text must not touch. Boxes that hid overflow cut the bottoms of letters in our test. our test
  4. Install your licensed brand fonts, and fonts for every script you publish in (for example Japanese, Arabic, emoji), on the machine that renders.

Move your data

  1. Export the rows you render from your spreadsheet or CMS as CSV or JSON, and download the images they point at into one assets folder.

Check it worked

  1. Have one agent run every test case and a separate pass grade them: run the PNG checker, look at the hard images (long titles, non-Latin text, fallbacks) and check every number in the replies. Fix the skill, not the outputs. our test
  2. Render one real batch in both tools and compare them side by side before you cancel.

Roll back

  1. Bannerbear can restore deleted project data if you re-subscribe and contact support within 30 days of the deletion. bannerbear.com

Watch out for

  1. Choosing 'Cancel now' deletes your Bannerbear data and stops API access at once; cancelling at the end of the billing period keeps both until then. bannerbear.com
  2. Instant URLs (images made from a link, used for dynamic og:image tags) are a Bannerbear Scale feature; this skill can't replace them. bannerbear.com
  3. A brand font that isn't installed falls back without any error in a browser. The renderer reports it, so read the report before posting. our test

Reviewed 2026-09-29.

Sources: bannerbear.comagentskills.iostackcut.io
Agent skilljson-render image skill (@json-render/image, Vercel Labs)Saves $188 in year one
$49/mo today → $0/mo + 0.5 h upkeep · setup 2 h · then $288/yr · payback 4.2 mo
OG images, social cards and other fixed-layout graphics rendered from JSON specs to SVG/PNG in your own code, instead of a per-image template-rendering API.
Covers 50% of the core features (not: Batch generation, API output)
Assumes you already pay for an agent that runs skills (an agent that supports Agent Skills (e.g. Claude Code/Cowork, Codex, Cursor, Gemini CLI); the agent's own subscription is not counted; a Node.js project); that agent's cost isn't counted. Setup (2 h) and upkeep (0.5 h a month) are Stackcut's estimates; not tested by Stackcut.
License: Apache-2.0
Install: npx skills add vercel-labs/json-render --skill image (project deps: @json-render/core, @json-render/image, and @resvg/resvg-js for PNG)
How we got this
You pay now: Bannerbear Automateflat price$49/mo
New cost: json-render image skill (@json-render/image, Vercel Labs)runs in the agent you already pay for$0/mo
Your upkeep time0.5 h/mo × $50/h$25/mo
Difference each month$49 − $0 − $25+$24/mo
Over 12 months+$24 × 12+$288
Setup, once2 h × $50/h−$100
Year one+$288 − $100+$188
  • Not counting your time (8 h in year one): saves $588 in year one.

Year one = 12 × (what you pay now − the new cost − upkeep) − setup, with your time at $50/hour. Prices are public list prices; hours are Stackcut’s planning estimates. Price it for your team

Sources: github.comraw.githubusercontent.combannerbear.com

Tested by Stackcut

Tested by Stackcut · Works, with caveats 2026-09-29 · Stackcut (our own test, not a customer)

Bannerbear seat → an agent skill that renders and checks template images on your machine

Question. Can an agent skill (SKILL.md, reference files, three HTML templates and a local Playwright script) render and check images from rows of data well enough to replace a Bannerbear Automate subscription, with nothing hosted? Path: Agent skill: render template images from data.

Tested on. Harbor & Pine Studio (an invented studio): An invented lettering and print studio with the three jobs small businesses pay a template-image tool for: link previews, portrait social posts and workshop certificates. Synthetic data only.

Numbers

  • 14 test cases, a checker that opens every PNG, and a strict grading pass
  • Pass rate by round: 10, 14 of 14; independent round (fresh runner, separate grader): 13 of 14
  • 50 link previews in 3.9 s, about 0.08 s per image, offline
  • About 3 to 6 minutes of agent time per test round

Verdict

A good replacement for a Bannerbear Automate seat when one person makes link previews, social posts or certificates from a spreadsheet and posts them by hand: every image is checked, and nothing leaves the machine. It doesn't replace Bannerbear if anything calls its API or uses its image URLs, because there is no API here. An independent round (fresh runner, separate grader) passed 13 of 14: every image was right, and one reply left out a font warning the render report had.

Good fit when

  • You render batches from a spreadsheet or CMS export, tens to hundreds of images a month
  • Your templates can be rebuilt in HTML/CSS and your fonts are licensed for it
  • A person reviews the images and posts or sends them

Not a fit when

  • Your site or app calls an image API, or og:image tags point at generated image URLs
  • You need app integrations (Zapier, Airtable, forms) or a visual editor for non-technical staff
  • You need video, animation or AI image features

What we found

  • Round 1's four failures were in the replies and one recommended column map, not in the rendering: two numbers the runner made up (a 110-character suggestion called 112, a 53-character file name called 60), a description of the certificate that wasn't true, and a map that printed the date twice. Each fix was a warning in the script, a report field or a sentence in the references.
  • A checker that opens every PNG is necessary but not enough. It passed all 14 cases in both rounds; the failures were found by looking at the images and checking every number in the replies against the reports.
  • Measuring the DOM misses cut letters. While building, before round 1, the first templates passed every measurement but sliced the bottoms of letters like p, because the title box hid overflow with a tight line-height. We only saw it by zooming in. The renderer now takes a second screenshot with every clipping box opened and fails the row if any pixel changes.
  • Fonts are the real portability risk. A missing brand font falls back silently in a browser; the renderer reads the font Chrome really used and says so. Japanese, Arabic and emoji rendered correctly on the test machine, but on a simulated bare Debian server (DejaVu fonts only) the Japanese title and a hieroglyph would have been empty boxes. The renderer caught both and made no image.
  • Speed isn't the problem at small-business volume: 50 link previews took 3.9 to 4.5 seconds, about 0.08 to 0.09 seconds per image.
  • Offline by design: the renderer blocks every web request and never downloads images or fonts, so rows with image URLs get the template's fallback and a warning until someone downloads the files. The shared test machine's proxy logged blocked ad-tracker requests from another browser process during the rounds; a socket check during renders showed none from the renderer.
  • It prepares files only. It never posts, uploads or emails; the replies give a person a checklist (for certificates, which file goes to which address).
  • In the independent round every image passed the checker; one reply (case 11) left out a font-fallback warning for one of three rows, so read the render report, not only the reply.
How we tested
  1. Wrote the skill in the agentskills.io format: SKILL.md (steps, output format, Never list), references/ for templates, brand and checks, assets/templates/ with three HTML/CSS templates (1200x630 link preview, 1080x1350 portrait post, 1754x1240 certificate) and scripts/render.mjs (Node and Playwright's Chromium, no network).
  2. The renderer fills the template once per CSV or JSON row, shrinks text to fit down to a minimum size, and checks before it writes anything: text boxes measured in the DOM, a second screenshot with every clipping box opened (any changed pixel means cut letters), keep-clear areas, images that didn't load, characters no installed font can draw, the fonts Chrome really used (read over the DevTools protocol), the PNG size read back from the file, and safe, unique file names.
  3. Wrote 14 test cases, a pass/fail rubric and a checker (tests/check.py) before the first run. The checker opens every PNG (signature, CRCs, size, full decode, not blank), checks names, and compares each report with the files. Cases: a ~120 and a ~290-character title, Japanese, Arabic and emoji, a missing file, a web address and a path outside the assets folder, a blank required name, portrait and landscape from one JSON file, a 50-row batch, a brand font that isn't installed, messy CMS slugs with markup in a title, a date that conflicts with the request, a square size with no template, a video and AI request, a request to email and post, and a bare server without Japanese fonts.
  4. The author's rounds: the runner and the grader were separate passes by the same agent (no Agent tool in that session). The runner used only the skill folder and cases.md. The grader started from the rubric, the references and the run file, ran the checker, looked at 12 images itself and checked every number in the replies.
  5. Between rounds we changed only the skill (the script, two reference files and one template), never the outputs.
  6. After the skill was final, Stackcut ran one independent round: a fresh runner agent (skill folder and case inputs only) and a separate grader agent (rubric, references, checker). Result: 13 of 14; failed: case 11.

Compare before you switch

Read the checked comparisons and workload guides for the tools this recipe replaces.

All 139 recipes · Savings leaderboard · Every vendor, with prices and cancel steps