QR Code API
Integration Guide

QRMint provides a completely free QR code API that any developer can call without registration, without an API key, and without OAuth tokens. The base URL for all endpoints is https://qrmint.dev/api/v1. The API returns binary image data (PNG or SVG) for simple generation requests, and JSON responses for batch and typed endpoints. Every parameter available in the playground above maps directly to an API query parameter or JSON body field, so what you see is exactly what your code will produce. There are no hidden premium tiers, no watermarks on free usage, and no feature restrictions. The API is rate-limited to 30 requests per minute per IP address to ensure fair access for all developers. Below you will find complete, runnable code examples in cURL, JavaScript, and Python that you can copy directly into your project.

Quick Start — cURL

The simplest way to test the QR code API is with a single cURL command from your terminal. The GET endpoint at /api/v1/generate accepts query parameters and returns the QR code image directly. Pipe the output to a file, and you have a production-ready QR code in PNG format. This is ideal for shell scripts, CI/CD pipelines, and quick prototyping where you need a QR code without writing application code. Adjust the data parameter to encode any URL, text string, or structured content you need.

curl "https://qrmint.dev/api/v1/generate?data=https://example.com&size=512&format=png" \
  --output qrcode.png

You can add styling parameters directly to the URL. For example, to generate a QR code with a dark cyan foreground, a near-black background, rounded modules, and leaf-shaped eyes, append the corresponding parameters to the query string. The API processes all styling server-side and returns the final image — no post-processing on your end.

curl "https://qrmint.dev/api/v1/generate?data=https://example.com&size=1024&format=png&fg=%2300f0ff&bg=%230a0a0f&moduleStyle=rounded&eyeShape=leaf&ecLevel=H" \
  --output styled-qrcode.png

JavaScript (Fetch API)

In a browser or Node.js environment, the native fetch API is all you need. The following example generates a QR code for a given URL, converts the response to a blob, creates an object URL, and sets it as the source of an <img> element on the page. This pattern works for any frontend framework — React, Vue, Svelte, or plain HTML. There are no dependencies to install and no CORS restrictions since the QRMint API allows cross-origin requests from any domain. For server-side Node.js, replace the DOM manipulation with fs.writeFileSync to save the buffer to disk.

async function generateQRCode(url) {
  const params = new URLSearchParams({
    data: url,
    size: "512",
    format: "png",
    moduleStyle: "rounded",
    eyeShape: "circle",
    fg: "#1a5276",
    bg: "#eaf2f8"
  });

  const response = await fetch(
    `https://qrmint.dev/api/v1/generate?${params}`
  );
  const blob = await response.blob();
  const objectUrl = URL.createObjectURL(blob);

  document.getElementById("qr-image").src = objectUrl;
}

generateQRCode("https://example.com");

For Node.js backend applications, the same endpoint works with the built-in fetch (Node 18+) or the node-fetch package for earlier versions. Write the response buffer directly to the filesystem or stream it to your HTTP response for on-the-fly QR code generation in Express, Fastify, or any other server framework.

import { writeFileSync } from "fs";

const params = new URLSearchParams({
  data: "https://example.com",
  size: "1024",
  format: "png"
});

const response = await fetch(
  `https://qrmint.dev/api/v1/generate?${params}`
);
const buffer = Buffer.from(await response.arrayBuffer());
writeFileSync("qrcode.png", buffer);

console.log("QR code saved to qrcode.png");

Python (Requests Library)

Python developers can use the ubiquitous requests library to generate QR codes with a single function call. No QR-specific packages like qrcode or Pillow are needed — QRMint handles all rendering server-side and returns the finished image as binary data. The params dictionary maps cleanly to the API’s query parameters. This pattern integrates seamlessly into Django views, Flask routes, FastAPI endpoints, and standalone scripts. For Flask, return the image directly with send_file(io.BytesIO(response.content), mimetype="image/png") instead of writing to disk.

import requests

response = requests.get(
    "https://qrmint.dev/api/v1/generate",
    params={
        "data": "https://example.com",
        "size": 512,
        "format": "png",
        "fg": "#ff00aa",
        "bg": "#0a0a0f",
        "moduleStyle": "dots",
        "eyeShape": "rounded",
        "ecLevel": "H"
    }
)

with open("qrcode.png", "wb") as f:
    f.write(response.content)

print(f"QR code saved ({len(response.content)} bytes)")

POST Endpoint — Advanced Styling

For advanced customisation that goes beyond simple query parameters — such as gradient foregrounds, logo embedding, and frame templates — use the POST endpoint at /api/v1/generate with a JSON body. The POST endpoint accepts the same parameters as GET, plus additional fields for gradients, base64-encoded logos, and frame configuration. This is the recommended approach for production integrations where you need full control over the QR code appearance. The response is the binary image data in the requested format.

curl -X POST "https://qrmint.dev/api/v1/generate" \
  -H "Content-Type: application/json" \
  -d '{
    "data": "https://example.com",
    "size": 1024,
    "format": "png",
    "bg": "#ffffff",
    "moduleStyle": "classy-rounded",
    "eyeShape": "leaf",
    "ecLevel": "H",
    "frame": "scan-me",
    "gradient": {
      "type": "linear",
      "colors": ["#ff00aa", "#00f0ff"],
      "angle": 135
    }
  }' --output branded-qrcode.png

The gradient object replaces the flat fg colour when present. Set type to "linear" or "radial", provide an array of two hex colours, and optionally specify the angle in degrees for linear gradients. To embed a logo, include a logo field with the base64-encoded image data string. When using a logo, always set ecLevel to "H" (High) to ensure the QR code remains scannable with the central area partially obscured by the logo.

Batch Generation

When you need to generate multiple QR codes in a single request — for example, printing QR labels for a product catalogue, creating attendee badges for an event, or generating unique payment codes — use the batch endpoint at POST /api/v1/batch. Send an array of up to 50 items, each with its own data and optional styling overrides, and receive a ZIP archive containing all generated QR codes. Shared styling properties can be set at the top level and are inherited by each item unless overridden. This approach is dramatically faster than making 50 individual requests and simplifies your integration code.

import requests

response = requests.post(
    "https://qrmint.dev/api/v1/batch",
    json={
        "size": 512,
        "format": "png",
        "moduleStyle": "rounded",
        "fg": "#1a5276",
        "bg": "#eaf2f8",
        "items": [
            {"data": "https://example.com/product/1", "filename": "product-1"},
            {"data": "https://example.com/product/2", "filename": "product-2"},
            {"data": "https://example.com/product/3", "filename": "product-3"}
        ]
    }
)

with open("qrcodes.zip", "wb") as f:
    f.write(response.content)

print("Batch ZIP downloaded successfully")

Typed QR Codes — WiFi, vCard, Email, and More

Beyond plain URLs and text, QRMint supports structured QR code types via the POST /api/v1/generate/typed endpoint. Instead of manually constructing the encoded payload string for WiFi credentials, vCard contact information, or calendar events, you send a JSON object with human-readable fields and the API handles the encoding for you. This eliminates encoding errors and ensures your QR codes comply with the relevant standards (e.g., the vCard 3.0 specification, the MECARD WiFi format, the iCalendar VEVENT structure). The following example generates a WiFi QR code that, when scanned, automatically connects the user’s device to the specified network.

const response = await fetch("https://qrmint.dev/api/v1/generate/typed", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    type: "wifi",
    wifi: {
      ssid: "OfficeNetwork",
      password: "s3cur3P@ss",
      encryption: "WPA"
    },
    size: 512,
    format: "png",
    moduleStyle: "dots",
    frame: "wifi"
  })
});

const blob = await response.blob();
const url = URL.createObjectURL(blob);
document.getElementById("wifi-qr").src = url;

Supported types include url, text, wifi, email, phone, sms, vcard, event, epc (European Payment Council), and geo (location coordinates). Each type has its own set of fields documented in the full API reference. The typed endpoint is the recommended approach for any structured data type because it handles escaping, formatting, and validation automatically.