guide

QR Codes for Event Tickets and Check-In Guide

By SoftVoyagers 9 min read

Why QR Codes Dominate Event Ticketing

QR codes have replaced barcodes as the standard for event check-in. They scan faster, hold more data, work from phone screens, and resist damage better than traditional barcodes. From music festivals to corporate conferences, QR-based ticketing reduces wait times and eliminates most forms of ticket fraud.

This guide covers everything you need to implement QR codes for events — from generating unique ticket codes to building a check-in system that handles thousands of attendees.

How Event QR Codes Work

The typical event QR ticketing flow has four stages:

1. Ticket Generation

Each ticket gets a unique identifier. This ID is encoded into a QR code and sent to the attendee via email, app notification, or printed ticket.

curl -X POST https://qrmint.dev/api/v1/generate \
  -H "Content-Type: application/json" \
  -d '{
    "data": "TICKET:EVT-2026-CONF:ATT-00482:VIP:2026-04-15",
    "size": 400,
    "errorCorrection": "H"
  }'

The encoded data typically includes:

  • Event identifier — Which event this ticket belongs to
  • Attendee ID — Unique per ticket, links to your database
  • Ticket tier — General admission, VIP, backstage, etc.
  • Event date — When the ticket is valid

2. Distribution

Tickets reach attendees as:

  • Email attachments — PNG or PDF with the QR code embedded
  • Mobile wallet passes — Apple Wallet or Google Wallet integration
  • Printed tickets — Physical tickets with the QR code printed at high resolution
  • In-app display — The event app shows the QR code on the attendee's screen

3. Check-In Scanning

At the venue entrance, staff use phones, tablets, or dedicated scanners to read each QR code. The scanner app queries a backend database to verify the ticket is valid and has not already been used.

4. Validation and Entry

The backend checks:

  • Does this ticket ID exist?
  • Has it already been scanned (preventing reuse)?
  • Is it valid for today's date and this entrance?
  • What access level does it grant?

The scanner shows a green checkmark or red X, and the attendee enters or is turned away.

Setting Up QR Tickets for Your Event

Step 1: Design Your Data Format

Keep the encoded data structured but concise. Shorter data produces simpler, faster-scanning QR codes.

Recommended format:

TICKET:{EVENT_CODE}:{ATTENDEE_ID}:{TIER}:{DATE}

Example:

TICKET:TECHCONF2026:ATT-00482:GA:2026-04-15

For multi-day events, encode the date range or use a session identifier:

TICKET:MUSICFEST:ATT-12847:3DAY:2026-06-20-22

Step 2: Generate Unique QR Codes

Generate one QR code per ticket using the QRMint API. For events with many attendees, use the bulk QR generator:

const attendees = [
  { id: 'ATT-00001', tier: 'VIP' },
  { id: 'ATT-00002', tier: 'GA' },
  { id: 'ATT-00003', tier: 'GA' },
];

for (const attendee of attendees) {
  const ticketData = `TICKET:CONF2026:${attendee.id}:${attendee.tier}:2026-04-15`;

  const response = await fetch('https://qrmint.dev/api/v1/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      data: ticketData,
      size: 600,
      errorCorrection: 'H',
      style: { foreground: '#1a1a2e', background: '#ffffff' }
    })
  });

  const qrBlob = await response.blob();
}

Tips for generation:

  • Use error correction level H (30%) — tickets get folded, creased, and displayed on cracked phone screens
  • Generate at 600px or higher for print quality
  • Use high-contrast colors (dark foreground, light background) for reliable scanning
  • Store the mapping between attendee ID and QR data in your database

Step 3: Build the Check-In Flow

Your check-in system needs three components:

A. Scanner App

Use any device with a camera. Most modern phones scan QR codes natively. For dedicated check-in, build a simple web app that uses the device camera:

async function validateTicket(scannedData) {
  const response = await fetch('/api/checkin', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ ticketData: scannedData })
  });

  const result = await response.json();

  if (result.valid) {
    showGreenCheck(result.attendeeName, result.tier);
  } else {
    showRedX(result.reason);
  }
}

B. Backend Validation

Your server checks the ticket against the database:

app.post('/api/checkin', async (req, res) => {
  const { ticketData } = req.body;
  const parts = ticketData.split(':');

  const ticket = await db.tickets.findOne({
    eventCode: parts[1],
    attendeeId: parts[2]
  });

  if (!ticket) return res.json({ valid: false, reason: 'Ticket not found' });
  if (ticket.scannedAt) return res.json({ valid: false, reason: 'Already checked in' });
  if (ticket.eventDate !== today()) return res.json({ valid: false, reason: 'Wrong date' });

  await db.tickets.updateOne(
    { _id: ticket._id },
    { $set: { scannedAt: new Date(), scannedBy: req.staffId } }
  );

  res.json({ valid: true, attendeeName: ticket.name, tier: ticket.tier });
});

C. Dashboard

A real-time dashboard showing:

  • Total tickets sold vs. checked in
  • Check-in rate over time (useful for staffing decisions)
  • Flagged tickets (duplicates, invalid codes)

Step 4: Test Before the Event

Run a full rehearsal with your team:

  1. Generate 20-50 test tickets
  2. Print some, display others on phone screens
  3. Test scanning in the actual venue lighting conditions
  4. Verify the duplicate-scan rejection works
  5. Test with damaged or partially covered QR codes
  6. Measure average scan-to-validation time (target: under 2 seconds)

Security Best Practices

Prevent Ticket Duplication

The most common fraud is sharing a screenshot of a valid ticket. Defenses:

  • Single-scan enforcement — Mark each ticket as used immediately after the first scan. Reject subsequent scans of the same code.
  • Unique IDs per ticket — Never encode generic data like just the event name. Every ticket must have a unique identifier.
  • Server-side validation — Never validate tickets client-side. The check must hit your database.

Prevent Ticket Forgery

  • Cryptographic signing — Sign the ticket data with a secret key. The scanner verifies the signature before accepting:
const crypto = require('crypto');

function signTicket(ticketData, secret) {
  const hmac = crypto.createHmac('sha256', secret);
  hmac.update(ticketData);
  return `${ticketData}:${hmac.digest('hex').substring(0, 8)}`;
}

function verifyTicket(signedData, secret) {
  const parts = signedData.split(':');
  const signature = parts.pop();
  const ticketData = parts.join(':');
  const expected = crypto.createHmac('sha256', secret)
    .update(ticketData).digest('hex').substring(0, 8);
  return signature === expected;
}
  • Database lookup — Even with signing, always verify against your database. A valid signature on a cancelled ticket should still be rejected.

Handle Edge Cases

Scenario Solution
Attendee's phone dies Offer a ticket lookup by name + ID at a staffed desk
WiFi goes down at venue Cache the ticket database locally on check-in devices
Same ticket scanned twice Show "Already checked in at [time]" with attendee name
Ticket for wrong date Show "Valid for [correct date]" — helpful, not just rejected
VIP at general entrance Accept and flag for staff — don't block entry

QR Code Design for Tickets

Sizing

The QR code on a ticket should be at least 3 cm x 3 cm (1.2 x 1.2 inches) for printed tickets. For on-screen display, 300px minimum width at full phone brightness. See our QR code size guide for detailed recommendations.

Quiet Zone

Maintain a white border (quiet zone) around the QR code equal to at least 4 modules (the small squares in the pattern). Without this margin, scanners may fail to detect the code.

Branding

You can customize QR codes with your event's colors and even add a small logo in the center. Use high error correction (H level) if adding a logo — it allows up to 30% of the pattern to be obscured:

curl -X POST https://qrmint.dev/api/v1/generate \
  -H "Content-Type: application/json" \
  -d '{
    "data": "TICKET:CONF2026:ATT-00482:VIP:2026-04-15",
    "size": 600,
    "errorCorrection": "H",
    "style": {
      "foreground": "#1a1a2e",
      "background": "#ffffff"
    }
  }'

For branded QR codes with logos, check the QR code with logo generator.

Print vs. Screen

Medium Minimum Size Resolution Error Correction
Printed ticket 3 cm 300 DPI M or H
Phone screen 300px Screen native H
Wristband 2 cm 300 DPI H
Badge/lanyard 2.5 cm 300 DPI M

Common Event Types and QR Strategies

Conferences and Trade Shows

  • Issue QR badges at registration (print on-site for security)
  • Use QR codes for session check-in to track attendance per talk
  • Encode attendee profile URLs for networking — scan someone's badge to get their vCard
  • Use the vCard QR generator for networking badges

Music Festivals and Concerts

  • Multi-day passes need date validation per scan
  • Consider wristband QR codes (waterproof printing required)
  • Multiple entry gates need real-time sync — all scanners must share state
  • Set up re-entry scanning (exit scan + re-entry scan)

Corporate Events and Workshops

  • QR codes on email invitations — attendees show their phone at the door
  • Track session attendance for CPD/CE credit verification
  • Use QR codes to distribute presentation slides post-session (link to PDF via PDFSpark)

Sporting Events

  • Section-specific validation — the QR code encodes the section/row/seat
  • Turnstile integration requires fast scan processing (under 500ms)
  • Paper tickets are common — use high error correction for folding resistance

Scaling for Large Events

For events with 5,000+ attendees, your system needs to handle scanning bursts. Most attendees arrive within a 1-hour window.

Performance targets:

Event Size Peak Scan Rate Recommended Setup
Under 500 2-5/min per gate 1 phone per gate
500-2,000 10-20/min per gate 2 devices per gate
2,000-10,000 30-50/min per gate Dedicated scanners + staff
Over 10,000 50+/min per gate Multiple gates + local cache

Key scaling decisions:

  • Local caching — Download the full ticket database to each scanner device before doors open. Validate locally, sync results when connected.
  • Multiple gates — Spread the load across entrances. Real-time sync between gates prevents double-entry.
  • Fallback process — Have a manual check-in desk for edge cases so the QR line keeps moving.

Integration with Other Tools

Build a complete event tech stack:

  • QR code generation — QRMint for creating ticket QR codes at scale
  • URL shortening — LinkShrink for trackable links on marketing materials
  • Landing pages — FreeKit for event landing page hosting
  • Open Graph images — OGForge for social sharing preview images
  • Event invoicing — Faktuj for generating sponsor and vendor invoices

Get Started

Generate your first event ticket QR code in seconds — no signup, no API key:

curl -X POST https://qrmint.dev/api/v1/generate \
  -H "Content-Type: application/json" \
  -d '{
    "data": "TICKET:MYEVENT:ATT-001:GA:2026-04-15",
    "size": 600,
    "errorCorrection": "H"
  }'

For interactive testing, use the QRMint playground. For the complete API reference, visit the documentation.

Planning an event? Read our QR code for events page for ready-to-use templates, or check the business card QR guide for networking badges.

qr-codeeventticketscheck-insecurityguide
Share this article: Twitter LinkedIn
← Back to Blog

Related Articles

Part of the SoftVoyagers Ecosystem
LinkMeta PageShot PDFSpark OGForge LinkShrink Faktuj QRMint FreeKit PismoSzyteNaMiarę QRMint Kalkuluj MojeCV