Event Ticket Image Generation: QR Codes + Dynamic Data

Last month, a conference organizer came to me with a problem. She had 2,500 attendees registered and needed unique tickets for each one. QR codes, seat assignments, dietary preferences, session tracks. The event was in three days.

Her design team quoted two weeks. We did it in an afternoon.

Why event tickets need automationWhy Event Tickets Need Automation

Manual ticket creation doesn't scale. Period.

Think about what goes into a single event ticket:

• Attendee name (spelled correctly)
• Unique QR code for check-in
• Seat or zone assignment
• Event date and time
• Venue information
• Maybe a barcode for scanning

Now multiply that by hundreds or thousands of attendees. Each ticket must be unique. Each QR code must link to the right person. One typo means chaos at the door.

This is exactly what Imejis.io was built for. You create one template, then let the API handle the rest.

How event ticket generation worksHow Event Ticket Generation Works

The process is simpler than you'd think:

1. Design your ticket template with placeholder fields
2. Mark dynamic elements like name, seat, and QR code
3. Call the API with attendee data
4. Receive unique tickets ready for printing or email

Let's walk through a real example.

Building your ticket templateBuilding Your Ticket Template

Start in the Imejis.io editor. Design your ticket with these elements:

• Text field for attendee name
• Text field for seat/zone
• Image placeholder for QR code
• Text field for event details
• Background image or color

The editor works like Canva. Drag, drop, resize, and style. No design degree required.

Once your design looks good, mark which fields should be dynamic. These become your API parameters.

Generating tickets via apiGenerating Tickets via API

Here's where the magic happens. A single API call creates a fully personalized ticket.

curl -X POST "https://render.imejis.io/v1/YOUR_TICKET_DESIGN_ID" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "attendee_name": "Sarah Johnson",
    "seat_number": "A-127",
    "event_date": "March 15, 2026",
    "qr_code_image": "https://api.qrserver.com/v1/create-qr-code/?data=TICKET-SJ-127"
  }'

That's it. The API returns a fully rendered ticket image with Sarah's information inserted into your template.

Nodejs example for bulk generationNode.js Example for Bulk Generation

Most events won't generate one ticket at a time. Here's how to process an entire attendee list:

const axios = require("axios");
const fs = require("fs");
 
const DESIGN_ID = "your-ticket-design-id";
const API_KEY = "your-api-key";
 
const attendees = [
  { name: "Sarah Johnson", seat: "A-127", email: "sarah@example.com" },
  { name: "Mike Chen", seat: "A-128", email: "mike@example.com" },
  { name: "Lisa Rodriguez", seat: "B-045", email: "lisa@example.com" }
];
 
async function generateTicket(attendee) {
  const qrData = `TICKET-${attendee.seat}-${Date.now()}`;
  const qrUrl = `https://api.qrserver.com/v1/create-qr-code/?size=200x200&data=${encodeURIComponent(qrData)}`;
 
  const response = await axios({
    method: "post",
    url: `https://render.imejis.io/v1/${DESIGN_ID}`,
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json"
    },
    data: {
      "attendee_name": attendee.name,
      "seat_number": attendee.seat,
      "qr_code_image": qrUrl
    },
    responseType: "arraybuffer"
  });
 
  const filename = `ticket-${attendee.seat}.png`;
  fs.writeFileSync(filename, response.data);
  console.log(`Generated: ${filename}`);
 
  return filename;
}
 
async function generateAllTickets() {
  for (const attendee of attendees) {
    await generateTicket(attendee);
  }
  console.log("All tickets generated!");
}
 
generateAllTickets();

Run this script, and you'll have individual ticket images for each attendee in seconds.

Generating qr codes that actually workGenerating QR Codes That Actually Work

Your QR codes need to encode useful data. Here's what works best for different scenarios:

For a simple approach, encode a unique ticket ID that your check-in system can verify:

const ticketId = `EVT-2026-${attendee.id}-${generateHash(attendee.email)}`;
const qrUrl = `https://api.qrserver.com/v1/create-qr-code/?size=300x300&data=${ticketId}`;

For security-sensitive events, consider encoding encrypted data or using a ticket verification service.

Real event types and their requirementsReal Event Types and Their Requirements

Different events need different ticket designs. Here's what you should include:

Conference ticketsConference Tickets

• Attendee name and company
• Registration type (speaker, VIP, general)
• Session track or day pass indicator
• Wi-Fi credentials
• QR code for badge printing

Concert ticketsConcert Tickets

• Seat or zone information
• Gate entry time
• Age restriction notice
• Unique barcode for scanning
• Event date and venue

Workshop ticketsWorkshop Tickets

• Participant name
• Workshop title and instructor
• Materials list or prep notes
• Room number
• Time slot

Scaling to thousands of ticketsScaling to Thousands of Tickets

When you're generating thousands of tickets, efficiency matters. Here are some tips:

Batch your requests wisely. Don't fire 5,000 API calls simultaneously. Process in batches of 10-20 with small delays between batches.

async function generateInBatches(attendees, batchSize = 10) {
  for (let i = 0; i < attendees.length; i += batchSize) {
    const batch = attendees.slice(i, i + batchSize);
    await Promise.all(batch.map(generateTicket));
    console.log(`Processed ${Math.min(i + batchSize, attendees.length)}/${attendees.length}`);
    await new Promise(resolve => setTimeout(resolve, 1000)); // 1 second pause
  }
}

Store generated tickets. Save them to cloud storage like S3 or Google Cloud Storage. Don't regenerate unless data changes.

Track generation status. Log which tickets succeeded and which failed. You'll want to retry failures without redoing everything.

Connecting to your registration systemConnecting to Your Registration System

Most event organizers use platforms like Eventbrite, Ticket Tailor, or custom registration forms. Connect them to Imejis.io using Zapier or Make.com. If you're new to Zapier, check out our Zapier integration guide to get started.

A typical workflow looks like this:

1. New registration comes in
2. Zapier triggers
3. Imejis.io generates ticket image
4. Email service sends ticket to attendee
5. Ticket stored in your records

This runs automatically. No manual intervention needed.

Cost breakdown for eventsCost Breakdown for Events

Let's talk numbers. Check out the pricing page for current rates.

At $24.99 for 10,000 tickets, you're paying less than a quarter of a cent per ticket. Compare that to manual design costs.

Best practices for event ticket designBest Practices for Event Ticket Design

After generating tickets for dozens of events, here's what works:

Keep text readable. Attendee names should be large enough to read at a glance. Check-in staff shouldn't need to squint.

Make QR codes prominent. At least 1 inch square for reliable scanning. Test with multiple phone cameras before printing.

Include essential info only. Ticket clutter creates confusion. Name, seat, date, QR code. That's usually enough.

Use high contrast. Dark text on light backgrounds. Printers and screens both handle this better.

Test before bulk generation. Generate five test tickets and verify they print correctly. Check QR codes actually scan.

Handling edge casesHandling Edge Cases

Real attendee data is messy. Plan for these scenarios:

Long names. Some names won't fit your text box. Use font sizing that auto-adjusts or set a character limit.

Special characters. Names with accents, apostrophes, or non-Latin characters need proper encoding.

Last-minute changes. Someone's seat changes the day before. Your system should regenerate single tickets easily.

Duplicate registrations. Check for duplicates before generating. You don't want two tickets with the same QR code.

Beyond basic ticketsBeyond Basic Tickets

Once you've mastered ticket generation, explore these extensions:

Dynamic badges. Use the same template system for name badges. Add attendee photos for enhanced security.

Session passes. Generate day-specific or track-specific passes from a single registration.

VIP upgrades. Regenerate tickets with premium designs when someone upgrades their registration.

Post-event certificates. Same workflow, different template. Generate completion certificates for workshops.

Check out the templates gallery for inspiration on badge and certificate designs.

FaqFAQ

How do i generate unique qr codes for each ticketHow do I generate unique QR codes for each ticket?

Use a QR code generation service like goQR.me or the Google Charts API. Pass a unique identifier for each attendee (ticket ID, registration number, or encrypted data). Include the generated QR code URL as an image field in your API call to Imejis.io.

Can i generate tickets in bulk from a spreadsheetCan I generate tickets in bulk from a spreadsheet?

Yes. Export your registration data to CSV or JSON, then loop through each row in your script. For no-code solutions, connect Google Sheets to Imejis.io via Zapier. Each new row automatically triggers ticket generation.

What image format works best for printing ticketsWhat image format works best for printing tickets?

PNG at 300 DPI works for most print shops. Imejis.io generates high-resolution images suitable for both digital display and professional printing. For thermal printers, you may need to convert to specific formats based on your hardware.

How do i handle ticket updates after initial generationHow do I handle ticket updates after initial generation?

Store a reference to each generated ticket along with the attendee data. When information changes, call the API again with updated data and replace the old ticket file. If you're emailing tickets, send an updated version with "Revised Ticket" in the subject line.

Is there a limit to how many tickets i can generateIs there a limit to how many tickets I can generate?

There's no hard limit on ticket quantity. Your plan determines monthly API calls. The Unlimited plan offers 100,000 calls per month, enough for even large-scale events. For massive events beyond that, contact the team about enterprise options.

Start generating event tickets todayStart Generating Event Tickets Today

Event ticket generation shouldn't take weeks. With the right tools, you can go from attendee list to finished tickets in hours.

Imejis.io handles the heavy lifting. You focus on running a great event.

Start with the free tier (100 tickets per month, no credit card). Design your template, connect your data, and let automation do the rest. Your check-in lines will thank you.

Create your first ticket template now