Price Tag Generator API: What 5,000 SKUs Actually Cost

Imejis' free price tag generator and sale banner generator each make one image at a time, in the browser, with no signup. A price tag generator API is the same design engine, called from your own script instead of a browser tab, so it runs once per SKU across a whole catalogue instead of once per visit. For 5,000 SKUs, a price tag and a sale banner each, that's 10,000 renders. The Pro plan, 10,000 renders a month for $24.99, covers exactly one pass with nothing left over that month for anything else.

The problem with the free tools at catalogue scaleThe problem with the free tools at catalogue scale

Price tag generator and sale banner generator are two of Imejis' 56 free tools. Both are client-side: you fill in a form, download a PNG, and you're done. Neither has a bulk mode, because neither is meant to have one. They're built for the one-off: a single hand-priced sign for a shop window, a sale banner for a single social post.

Both tool pages already point past themselves. The price tag generator's own page asks: "Need price tags for 1000 products? Generate them automatically with Imejis API + your product database." That's the right instinct, and it's also where most people stop reading, because nothing walks through what "1000 products" actually costs once you're inside the render quota instead of clicking a download button. That's the gap this post fills.

The approach one design looped over your catalogueThe approach: one design, looped over your catalogue

The free tool builds one image by hand. The API approach builds one reusable design, once, in the editor, then calls it with different data per SKU. Two designs, not one: a price tag design (product name, price, maybe a discount badge) and a sale banner design (headline, discount, a call to action), because their layouts differ enough that cramming both into one template creates more conditional logic than it saves.

Each design has a fixed size, set once when you build it. There's no resizing a design through the API, so if you need a square price tag for Instagram and a landscape one for your product listing, that's two designs, not one design with a size parameter. Budget for that when you're mapping out how many templates you actually need.

How to build itHow to build it

Step 1: Design the price tag template. In the editor, add a text field for the product name, a text field for the price, and a rect component behind them for the badge background. Give each a key so the render call can target it by name.

Step 2: Design the sale banner template. Same pattern: headline text, discount text, a CTA, and a rect or shape for the accent color block.

Step 3: Call the render API once per SKU, per design. A minimal payload for the price tag design:

curl -X POST 'https://render.imejis.io/v1/YOUR_PRICE_TAG_DESIGN_ID' \
  -H 'dma-api-key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "product_name": { "text": "Classic Runner" },
    "price": { "text": "$29.99" },
    "sale_badge": {
      "text": "40% OFF",
      "borderColor": "#e11d48",
      "borderWidth": 2
    }
  }'

Loop your product feed and call it once per SKU, then again against the sale banner design if you need both assets:

const products = loadFromCSV("products.csv")
 
async function render(designId, fields) {
  const res = await fetch(`https://render.imejis.io/v1/${designId}`, {
    method: "POST",
    headers: {
      "dma-api-key": API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(fields),
  })
  return res.blob()
}
 
for (const product of products) {
  await render(PRICE_TAG_DESIGN_ID, {
    product_name: { text: product.name },
    price: { text: `$${product.price}` },
  })
 
  if (product.on_sale) {
    await render(SALE_BANNER_DESIGN_ID, {
      headline: { text: product.name },
      discount: { text: `${product.discount_percent}% OFF` },
    })
  }
}

Step 4: Watch the quota, not just the render count. API renders and public-link renders draw from two separate pools on your plan, so a batch job against your API key won't eat into renders spent on a public link you shared with a client for a preview. That separation matters once you're running catalogue-sized batches alongside anything customer-facing.

Real examples the render mathReal examples: the render math

These numbers assume one render per SKU per design, which is the normal case unless you're also generating size variants.

The 10,000-render row is the one that trips people up. It's not that Pro can't handle a 5,000-SKU catalogue, it's that "price tags and sale banners in the same run" doubles the render count you were expecting, and a plan that looked comfortable turns out to have zero headroom for anything else that billing cycle: no test renders, no preview links, no re-run because a product name had a typo. If you're running both assets and doing it more than once a month, Unlimited's $0.0007 per render is the safer default, not a splurge.

What it costs and the trap that blows past itWhat it costs, and the trap that blows past it

The numbers above assume you generate each image once and save it. That's the part worth stating plainly, because it's the mistake that turns a $24.99 plan into an overage problem: every render costs one render, including a GET render URL embedded in an <img> tag on your storefront. That URL re-renders on every page load, not once. Put a live render URL on a product page that gets 5,000 views a day, and you've burned more renders by lunchtime than the entire catalogue batch cost. Generate once, host the static file, and only use a live URL when the image genuinely has to reflect data at the moment someone loads the page.

As of August 2026, plan pricing is $14.99/mo for 1,000 renders on Basic, $24.99/mo for 10,000 on Pro, and $69.99/mo for 100,000 on Unlimited, all with a a permanent free tier: 100 renders a month before you need a card. Overage rules vary by plan, and on some legacy plans renders simply stop until the next billing cycle resets, so check your plan's overage setting before you kick off a batch sized for your full catalogue. You can also upgrade mid-cycle if you run out partway through.

Getting startedGetting started

Prototype the layout by hand first in the price tag generator and sale banner generator tools, since that's the fastest way to settle on fonts, colors, and copy before you build the real design in the editor. Then:

1. Rebuild the layout as a design with dynamic text fields for product name, price, and discount.
2. Grab an API key and test against 10 real SKUs from your catalogue.
3. Loop the full feed, generating price tags and sale banners as separate calls per SKU.
4. Save the output rather than embedding a live render URL anywhere it'll be viewed repeatedly.

Manual editing doesn't scale past a few dozen SKUs, and that gap only gets wider as your catalogue grows, which is well documented outside the context of any one vendor. For the full CSV-to-image workflow, see batch image generation from CSV. For pricing overlays specifically, see dynamic product images with live pricing, and for the broader automation setup, e-commerce image automation. Check pricing and the API docs before you commit a plan to a full catalogue run.