Iteration Layer
Products
Blog
Docs
Recipes
All Recipes E-Commerce Education Finance & Accounting Healthcare Human Resources Legal Logistics & Shipping Manufacturing Marketing Publishing Real Estate Technology
Pricing
Login Get Started

Best Image Generation APIs in 2026

15 min read Image Generation

This Is Not About AI Art

When someone says “image generation API,” half the room thinks DALL-E. The other half thinks Midjourney. This guide is about neither.

Programmatic image generation is the practice of rendering images from data and templates. You have a layout — a background, some text, a logo, maybe a QR code. You have data — a blog title, a product name, a recipient’s name. You combine them and get an image out. Social cards. Certificates. Product listing images. OG images. Email banners. Event tickets.

The layout is fixed. The data changes. The output is deterministic. This is a function call, not a creative prompt.

If you’ve been generating these images by hand in Figma or Canva — exporting, renaming, uploading, repeating — you already know the problem. It doesn’t scale. The tools in this guide turn that manual process into an API call. The differences are in how they define templates, what they can render, and how much control you get.

The Categories

Programmatic image generation tools fall into six categories. Some tools span multiple categories, but the core approach defines how you’ll work with them day to day.

  • Visual template editors with an API. You design templates in a browser-based editor, then call an API to fill in dynamic values. Bannerbear, Placid, DynaPictures, Templated.io.
  • HTML/CSS rendering APIs. You send HTML and CSS, they render it in a headless browser, you get an image back. HTMLCSSToImage, APITemplate.io.
  • Layer-based APIs. You define images as a stack of typed layers in JSON — no editor, no browser. Iteration Layer.
  • Framework-specific tools. Tied to a specific framework or runtime. Satori and @vercel/og for React and Vercel.
  • Self-hosted/DIY. Run your own headless browser and take screenshots. Puppeteer, Playwright.
  • Video-first platforms with image support. Built for video automation, with image generation as a secondary feature. Creatomate, Shotstack.

Each category trades off control, flexibility, and operational complexity differently. The right choice depends on who owns your templates, what your rendering needs are, and how much infrastructure you want to manage.

Visual Template Editors with an API

Bannerbear

Bannerbear is the most established player in the visual-editor-plus-API category. You design templates in their browser-based drag-and-drop editor, name your dynamic fields, and call their REST API with a JSON payload that maps field names to values.

The editor is the selling point and the limitation. Marketing teams can create and modify templates without writing code. But those templates live in Bannerbear’s platform — not in your Git repo. You can’t diff two versions of a template. You can’t review a template change in a pull request. You can’t generate templates dynamically from code.

Bannerbear supports custom fonts via upload, basic image manipulation, and integration with no-code tools like Zapier and Make. The API is clean and well-documented. The limitation is structural: templates are platform state, not code.

  • Pricing: Starts at $49/month for 1,000 images. Free tier: 30 images.
  • Best for: Marketing teams who own the template design process and need a no-code workflow.

Placid

Placid follows the same model as Bannerbear — visual editor, API for dynamic data — but at a lower entry price. The editor supports text, images, and basic shapes. You design templates in their browser-based studio and call their API or use integrations with Make, Zapier, and Airtable.

Placid’s credit system starts at $19/month for 500 images. That’s a low ceiling for automated pipelines. A course platform generating certificates for a graduating cohort of 2,000 students burns through four months of credits in one afternoon. The next tier — $39/month for 2,500 — gives more room, but the per-image cost at the entry level ($0.038) is higher than most alternatives.

Placid doesn’t support HTML/CSS rendering, Markdown formatting in text, or auto-scaling text. Templates are plain-text layers positioned in the visual editor. If you need a single text block with mixed bold and regular text, you’re splitting it into multiple layers and aligning them by hand.

  • Pricing: Starts at $19/month for 500 images. Free trial available.
  • Best for: Low-volume use cases where a non-technical team needs simple image automation.

DynaPictures

DynaPictures occupies the same visual-editor space as Bannerbear and Placid, with a focus on personalized images for marketing automation. Design templates in the editor, fill them via API or CSV upload.

DynaPictures integrates with HubSpot, Mailchimp, and other marketing platforms. It’s positioned more toward marketing personalization — personalized email images, dynamic social cards — than developer-driven automation.

  • Pricing: Free plan available. Lite plan at $29/month for 500 images.
  • Best for: Marketing teams focused on email personalization and social media automation.

HTML/CSS Rendering APIs

HTMLCSSToImage

HTMLCSSToImage (HCTI) is the most focused tool in this category. Send HTML and CSS to their API, they render it in headless Chrome, you get an image back as PNG, JPEG, or WebP.

The value proposition is simple: you already know HTML and CSS, so use that knowledge to define image templates. No new template language, no visual editor. Your templates are strings of HTML, version-controlled in your codebase, rendered by a browser engine you don’t have to host.

The tradeoff is the browser itself. Chrome rendering is nondeterministic — font loading is a race condition, layout calculations can shift between Chrome versions, and a 30-second render timeout means slow-loading external assets can fail the request. HCTI imposes a 50 MB payload limit on HTML/CSS.

HCTI doesn’t include built-in fonts, QR code generation, barcode rendering, or AI features like background removal. If you need a QR code, you generate it with a JavaScript library and embed it in your HTML. If you need to remove a background from a photo, you do that before sending the HTML.

  • Pricing: Starts at $14/month for 1,000 images. Free tier available.
  • Best for: Developers who think in HTML/CSS and want to reuse existing web templates.

APITemplate.io

APITemplate.io straddles the visual-editor and HTML/CSS categories. It offers both a drag-and-drop template editor and the ability to render HTML/CSS templates. This makes it more flexible than pure visual-editor tools, but it also means the product is broader and less focused.

The visual editor works similarly to Bannerbear — design templates, fill via API. The HTML/CSS mode renders your markup like HCTI does. APITemplate.io also supports PDF generation from templates, which makes it a broader document automation tool rather than a pure image generation API.

  • Pricing: Starts at $24/month. Free plan available.
  • Best for: Teams that want both visual templates and HTML/CSS rendering in one platform.

Layer-Based APIs

Iteration Layer

Iteration Layer takes a fundamentally different approach. There’s no visual editor. There’s no browser. You define images as a stack of typed layers in JSON, and the API composes them directly into pixels.

Eight layer types cover the building blocks of programmatic image composition:

  • solid-color-background — full-canvas fill
  • gradient — linear gradients with configurable angle and color stops
  • rectangle — positioned shapes with borders, corner radius, and angled edges
  • text — with font selection, Markdown formatting, auto-scaling, and alignment
  • static-image — images from URLs with optional AI background removal and smart crop
  • image-overlay — compositing images with the same AI features
  • qr-code — generated from any URL or string
  • barcode — six formats including Code 128, EAN-13, and Codabar

Every property is explicit. Position in pixels, size in pixels, font size in pixels, color in hex. No drag-and-drop approximation — you specify exactly what you want and get exactly that back.

Templates are JSON. That means they live in your codebase, go through code review, and can be generated dynamically from any data source. A function that takes a product’s metadata and constructs a layer stack is your “template.” The variations are infinite without creating a single template in an editor.

The API bundles 98 fonts — Inter, Roboto, Open Sans, Noto Sans (including CJK, Arabic, and Telugu variants), Playfair Display, and dozens more. Custom fonts via TTF, OTF, WOFF, or WOFF2 upload if the bundled set doesn’t cover your brand typeface. No font hosting, no CDN, no race conditions.

AI features are built into image layers. Set remove_background: true on a static-image layer and AI segmentation removes the background at render time. Set smart_crop: true and AI object detection frames the subject. These run as part of the composition pipeline — no separate API call, no pre-processing step.

Six output formats — PNG, JPEG, WebP, TIFF, GIF, and AVIF — are a parameter on the request, not a post-processing step.

Because there’s no browser in the rendering pipeline, output is deterministic. Same input, same output, every time. No Chrome version drift, no font loading race conditions, no subpixel rendering differences.

Here’s what an OG image looks like in code:

import { IterationLayer } from "iterationlayer";

const client = new IterationLayer({ apiKey: "YOUR_API_KEY" });

const result = await client.generate({
  width_in_px: 1200,
  height_in_px: 630,
  format: "png",
  layers: [
    { type: "gradient", direction: "linear", angle_in_deg: 135,
      stops: [
        { color: "#0f172a", position: 0 },
        { color: "#1e293b", position: 100 },
      ]},
    { type: "text", text: "**Best Image Generation APIs in 2026**",
      x_in_px: 60, y_in_px: 60, width_in_px: 800, height_in_px: 200,
      font_family: "Inter", font_size_in_px: 48, color: "#f8fafc" },
    { type: "text", text: "iterationlayer.com",
      x_in_px: 60, y_in_px: 540, width_in_px: 400, height_in_px: 40,
      font_family: "Inter", font_size_in_px: 18, color: "#94a3b8" },
    { type: "qr-code", value: "https://iterationlayer.com/blog/best-image-generation-api",
      x_in_px: 1040, y_in_px: 470, width_in_px: 120, height_in_px: 120,
      fg_hex_color: "#f8fafc", bg_hex_color: "#0f172a" },
  ],
});

Four layers, one request. A gradient background, a bold title via Markdown, a URL slug, and a QR code linking to this post. The entire definition is code — reviewable, testable, dynamically composable.

  • Best for: Developers who want full programmatic control over image composition, with no editor or browser in the pipeline.

Framework-Specific Tools

Satori / @vercel/og

Satori is an open-source library by Vercel that converts JSX components to SVG. @vercel/og wraps Satori into a package optimized for Vercel Edge Functions, adding the SVG-to-PNG conversion step. Together, they let you generate OG images from React components — free, with no external API call.

For basic social cards on a Next.js app deployed to Vercel, this is the path of least resistance. The integration is tight, the cost is zero, and for a title-on-gradient card, it works.

The limitations are real. Satori implements a subset of CSS Flexbox — not the full spec. Missing features include z-index, backgroundSize: cover, gap, viewport units, and advanced typography like font-kerning or font-variant-ligatures. No RTL language support. No variable fonts. Font loading requires fetching TTF/OTF files at runtime and passing them as ArrayBuffers, which adds to your edge function bundle size. Only TTF, OTF, and WOFF are supported — no WOFF2.

Satori requires JSX. If your backend is Python, Go, Elixir, or anything that isn’t a JavaScript runtime, you need a separate Node.js service just for image generation. The components must be pure and stateless — no hooks, no side effects. It’s JSX syntax for markup, not React for application logic.

  • Pricing: Free and open source.
  • Best for: OG images in Next.js apps on Vercel, where the design stays within Satori’s CSS subset.

Self-Hosted / DIY

Puppeteer and Playwright Screenshots

Puppeteer (Chrome) and Playwright (Chrome, Firefox, Safari) let you render any HTML page in a headless browser and capture a screenshot. This is the most flexible approach — anything a browser can render, you can screenshot. Full CSS support, JavaScript execution, web fonts, animations frozen at a specific frame.

The cost is operational complexity. You’re running headless browsers in your infrastructure. That means Docker containers, memory management (Chrome is not lightweight), concurrency limits, and cold start times. Font installation happens at the OS level in your container. Browser versions need to be pinned and updated.

For teams that already run headless browsers for testing or scraping, adding image generation to the same infrastructure is a small step. For everyone else, the setup and maintenance cost is real — and it’s the reason hosted APIs like HTMLCSSToImage exist.

  • Pricing: Free (open source). Infrastructure costs are yours.
  • Best for: Teams with existing headless browser infrastructure who need the full power of a browser engine.

Video-First Platforms with Image Support

Creatomate

Creatomate is a video automation platform that also supports image generation. You design templates in their visual editor — which supports both static and animated content — and render via API. The editor is more capable than Bannerbear or Placid for motion design, but that capability comes with complexity that’s overkill if you only need static images.

Creatomate uses a credit system where images and videos draw from the same pool. The Essential plan starts at $41/month for 2,000 credits. If your primary need is video automation and you occasionally need static images, Creatomate makes sense. If you only need images, you’re paying for video features you won’t use.

  • Pricing: Starts at $41/month for 2,000 credits. Free trial with 50 credits.
  • Best for: Teams that need video automation and want image generation from the same platform.

Shotstack

Shotstack follows a similar pattern — video-first API with image support. The API is developer-oriented with JSON-based templates and a render pipeline that handles both video and image output. Shotstack is more code-driven than Creatomate, with less emphasis on a visual editor and more on the API itself.

  • Best for: Video automation pipelines where static image generation is a secondary need.

Brief Mentions

A few tools worth knowing about, even if they don’t warrant a full section.

  • Templated.io — Visual editor with API, similar to Bannerbear. Starts at $29/month for 1,000 renders. Supports images, videos, and PDFs.
  • Orshot — Newer entrant positioning itself as a cheaper Bannerbear alternative. Visual editor with API. Worth watching, but less established.
  • Polotno — Open-source design editor (think Canva SDK) that you can embed in your own application. Not an image generation API itself, but the rendering engine can be used for programmatic generation if you self-host.
  • Canva Connect API — Canva’s API for integrating with Canva designs. Not a programmatic image generation tool — you’re connecting to the Canva ecosystem, not rendering images from data. Useful for workflows where users design in Canva and your app needs to access those designs.

Comparison Table

Tool Template Approach HTML/CSS Support Built-in Fonts AI Features Free Tier Starting Price
Bannerbear Visual editor No Limited No 30 images $49/mo
Placid Visual editor No Limited No Free trial $19/mo
DynaPictures Visual editor No Limited No Free plan $29/mo
HTMLCSSToImage HTML/CSS Yes (Chrome) System fonts only No Yes $14/mo
APITemplate.io Visual editor + HTML/CSS Yes (Chrome) System fonts No Free plan $24/mo
Iteration Layer JSON layers (code) No (layer-based) 98 fonts Background removal, smart crop — —
Satori / @vercel/og JSX (React) CSS subset Noto Sans (bundled) No Open source Free
Puppeteer HTML/CSS (self-hosted) Yes (full browser) OS-installed fonts No Open source Free + infra
Creatomate Visual editor No Via editor No 50 credits $41/mo
Templated.io Visual editor No Via editor No 50 credits $29/mo

How to Choose

The decision tree is shorter than the comparison table suggests. Most teams fall into one of six patterns.

Your marketing team owns templates. Go with Bannerbear or Placid. The visual editor is the point. Non-technical team members can create and modify templates without developer involvement. Bannerbear has more features and integrations. Placid is cheaper at low volumes.

You’re a developer who thinks in HTML/CSS. HTMLCSSToImage is the most focused option. Send HTML, get an image. You already know the template language. The tradeoffs — browser nondeterminism, font loading complexity, no built-in QR codes or AI features — are real but manageable for many use cases.

You need full programmatic control. Iteration Layer is built for this. Templates are code. Layers are typed. Fonts are bundled. AI features run at render time. No editor to click through, no browser to host, no font CDN to manage. If your templates are generated from data — different layouts for different product categories, conditional elements based on business logic, thousands of variations from a single function — the layer model is the natural fit.

You need OG images on Vercel and nothing else. @vercel/og and Satori are free, integrated, and sufficient for basic social cards. Know the CSS subset limitations before you commit. If your design needs z-index, background images that cover their container, or fonts beyond Noto Sans, you’ll hit walls quickly.

You need video too. Creatomate handles both video and image generation from one platform. The visual editor supports motion design. If your pipeline generates product videos and also needs static thumbnails, one tool for both reduces integration overhead.

You want maximum control and you’ll self-host. Puppeteer or Playwright give you a full browser engine. Anything CSS can render, you can screenshot. The cost is infrastructure — Docker containers, memory management, Chrome versioning, cold starts. If you already run headless browsers for testing, adding image generation is incremental. If not, the setup cost is significant.

What Matters Beyond Features

A few things that feature tables don’t capture.

Determinism. If you need identical output across runs — compliance documents, automated visual regression tests, images that must match a specification exactly — browser-based rendering is the wrong foundation. Chrome’s rendering shifts between versions. Layer-based and canvas-based approaches give you deterministic output.

Version control. Templates stored in a visual editor are platform state. Templates stored as code are Git-tracked, diffable, reviewable, and deployable through your existing pipeline. This matters less for a marketing team generating 50 social cards a month. It matters a lot for an engineering team building an automated pipeline that generates 50,000 product images.

Vendor lock-in. Visual editor templates aren’t portable. If you build 200 templates in Bannerbear and decide to switch, you’re rebuilding them from scratch. JSON layer definitions and HTML templates are data — they move with you.

Scaling cost. Credit-based pricing works differently at scale. At 100 images/month, every tool is cheap. At 100,000 images/month, the per-image cost and the pricing model — credits vs. pay-as-you-go vs. self-hosted — become the dominant factor. Model this before you commit.

Get Started

If you’re evaluating programmatic image generation for a new project, pick the category that matches your team structure and build a proof of concept with one tool. Generate a real image from real data. The API call takes minutes. The evaluation is whether the template model — visual editor, HTML/CSS, layers, JSX — fits how your team works.

For the layer-based approach, check the Iteration Layer docs for the full layer reference, font catalog, and SDK guides for TypeScript and Python.

Start building in minutes

Free trial included. No credit card required.

Start for free