Bulk QR Code Generator API: Programmatic Guide

To generate QR codes in bulk programmatically, send an array of strings (URLs, text, WiFi credentials) to a bulk QR code generator API and receive PNG or SVG outputs in a single request. The fastest path is a hosted API that accepts batch input, applies your brand colors and logo, and returns base64 images you can save or stream into a print pipeline. For 1,000+ codes per job, expect to pay roughly $5 per 1,000 generations — far cheaper than building, hosting, and maintaining your own renderer.

Quick Answer

A bulk QR code generator API lets you POST a list of payloads and get back styled QR images in one call, eliminating the need to loop over a single-code endpoint thousands of times. Popular options include QuickChart's batch endpoint, QRCode Monkey, QRKIT, and the QR Code API (bulk, image/logo support) on Apify. The Apify actor charges $0.00499 per code, supports PNG and SVG, custom colors, and center logos with automatic high error correction. You feed it JSON, it runs, and you pull results from the dataset. For most packaging, ticketing, or retail use cases, this replaces 200+ lines of canvas-rendering code with a config object.

Why generate QR codes in bulk instead of one-by-one?

Generating one QR code at a time works for a contact card. It breaks at scale. A printer asking for 50,000 unique product QR codes by Friday needs throughput, not a UI.

Concrete cases where bulk matters:

• Retail packaging: 10,000 SKUs each need a unique URL pointing to product authentication or warranty registration.
• Event ticketing: 5,000 attendees, each ticket carries a signed JWT inside a QR.
• Asset tagging: 25,000 office assets, each labeled with an inventory ID.
• WiFi rollout: 500 hotel rooms, each room's QR pre-encodes the network and password.
• Marketing campaigns: 200 print variants, each pointing to a tracked redirect.

A single-code endpoint at 200ms per call means 50,000 codes takes ~2.8 hours sequentially and burns rate limits. A batch endpoint cuts that to minutes.

What is the best bulk QR code generator API?

Four tools dominate developer chatter. Each has a different sweet spot:

If you need styled codes with a center logo and don't want a subscription floor, the Apify actor's pay-per-result model is the cheapest for variable workloads. You pay $4.99 for 1,000 codes, nothing if you don't run.

How do you generate QR codes programmatically with an API?

Here's the minimal flow using the Apify QR Code API. First, install the client:

npm install apify-client

Then call the actor with a list of inputs:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const input = {
  items: [
    { data: 'https://example.com/product/1001', filename: 'sku-1001' },
    { data: 'https://example.com/product/1002', filename: 'sku-1002' },
    { data: 'WIFI:T:WPA;S:GuestNet;P:welcome2024;;', filename: 'wifi-lobby' },
  ],
  format: 'png',
  darkColor: '#0A2540',
  lightColor: '#FFFFFF',
  logoUrl: 'https://yourcdn.com/logo.png',
  errorCorrection: 'H',
};

const run = await client.actor('qr-code-api').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const item of items) {
  const base64 = item.image.replace(/^data:image\/png;base64,/, '');
  fs.writeFileSync(`./out/${item.filename}.png`, Buffer.from(base64, 'base64'));
}

That's the entire pipeline. 1,000 codes in one run, costs $4.99, takes a few minutes depending on logo processing.

How do I add a logo to QR codes in bulk?

Center logos require error correction level H (30% redundancy) so the code still scans when the logo obscures the middle. The Apify actor auto-bumps to H whenever you supply logoUrl, so you can't accidentally ship unscannable codes.

Practical rules for logo overlays:

1. Keep the logo under 20% of the QR's width. Bigger and you risk decode failures on cheap phone cameras.
2. Use a solid background behind transparent logos. A floating PNG over a busy QR pattern confuses scanners.
3. Pre-test 10 samples with iOS Camera, Google Lens, and a generic Android scanner. If all three decode at arm's length, ship the batch.
4. Avoid red/green dark modules. Some scanners struggle with low contrast against white. Stick to navy, black, or dark gray for darkColor.

If you're generating 5,000+ codes, render 20 random samples first and visually QA before committing the full run.

How do you handle 10,000+ QR codes without timing out?

Three patterns work in production:

Chunk and queue. Split your 10,000 inputs into batches of 500–1,000 and submit them as separate runs. The Apify actor processes each run independently, so you get parallelism without managing workers.

Stream to dataset, not memory. Don't try to hold 10,000 base64 PNGs in a single variable. Pull from the dataset with pagination:

let offset = 0;
const limit = 100;
while (true) {
  const { items } = await client.dataset(datasetId).listItems({ offset, limit });
  if (items.length === 0) break;
  await Promise.all(items.map(saveToS3));
  offset += limit;
}

Use SVG for print, PNG for screen. SVG output stays sharp at any size and the file payloads are smaller for simple codes. PNG at 512×512 is better when downstream tools don't render SVG.

For truly massive jobs (100k+), pre-generate the input list as a JSON or CSV file and use the actor's input file feature instead of an inline array — keeps your API request small.

How much does bulk QR code generation cost?

At commercial volumes, pricing shapes which tool you pick:

• Self-hosted (qrcode npm + sharp): ~$0 in software, but you pay for compute, storage, and engineering time. Realistically $200–500 in dev time for a robust batch endpoint with logo overlay.
• QRCode Monkey free tier: $0 but no official API — scraping their UI breaks terms of service and is fragile.
• QRKIT subscription: $19–99/month with quotas, regardless of usage.
• Apify QR Code API: $0.00499/code, no monthly minimum. 10,000 codes = $49.90.
• Commercial QR platforms (Beaconstac, QR Code Generator Pro): $20–500/month, often capped at a few hundred dynamic codes.

For one-off batches under 100k codes, pay-per-result wins on math. For continuous high-volume generation (1M+/month), a self-hosted renderer becomes cheaper around the 200k/month mark — but you inherit the maintenance burden.

Can I generate WiFi, vCard, and SMS QR codes in bulk?

Yes — QR content is just a string with a specific prefix. The renderer doesn't care what's inside.

Common payload formats:

URL:         https://example.com
WiFi:        WIFI:T:WPA;S:<ssid>;P:<password>;;
SMS:         SMSTO:+14155551234:Hello
Email:       mailto:hello@example.com?subject=Hi
vCard:       BEGIN:VCARD\nVERSION:3.0\nFN:Jane Doe\n...\nEND:VCARD
Geo:         geo:37.7749,-122.4194
Phone:       tel:+14155551234

Mix them in a single bulk run. A hotel might generate 200 WiFi codes (one per room) plus 200 vCards (one per concierge desk) plus 1 URL code for feedback — all in one API call, all with the same brand styling.

FAQ

Q: What's the minimum batch size for a bulk QR code generator API? There's no hard minimum on the Apify actor — you can submit 1 code or 100,000 in a single run. You only pay for what you generate, so there's no reason to artificially batch unless you want fewer run records.

Q: Will logos break QR code scanning? Not if you keep the logo under 20% of the code's width and use error correction level H. The Apify actor enforces H automatically when a logo is present, which preserves scannability even with the center 30% obscured.

Q: SVG or PNG for printed QR codes? Use SVG. It's vector, so it stays crisp at any print size (business cards to billboards) and files are typically smaller for simple codes. Only fall back to PNG if your print software or downstream tool doesn't support SVG.

Q: How do I make QR codes trackable? The QR itself is static — tracking happens at the destination URL. Generate each code with a unique short URL or tracked redirect (e.g., yourdomain.com/r/abc123) and log hits server-side. The bulk API generates the codes; your redirect service handles analytics.

Q: Can I customize colors beyond black and white? Yes. The Apify actor accepts hex codes for both darkColor and lightColor, so you can match brand palettes. Keep contrast above 4.5:1 between dark and light — light gray on white scans poorly, especially in low light.