Bulk QR Code Generator

Why Use Bulk Generation

CSV Format

Simple Format

url,filename
https://example.com/product/1,product_1
https://example.com/product/2,product_2
https://example.com/product/3,product_3

Advanced Format (with metadata)

sku,url,product_name,size
SKU001,https://example.com/1,Product A,300
SKU002,https://example.com/2,Product B,256
SKU003,https://example.com/3,Product C,400

Python Script - Local Batch Generation

Simple Batch Script

import qrcode
import csv
import os
from pathlib import Path

def batch_generate_qr(csv_file, output_dir):
    """Generate QR codes from CSV file"""
    
    # Create output directory
    Path(output_dir).mkdir(exist_ok=True)
    
    with open(csv_file, 'r', encoding='utf-8') as file:
        reader = csv.DictReader(file)
        
        for idx, row in enumerate(reader, 1):
            url = row.get('url') or row.get('link') or row.get('data')
            filename = row.get('filename', f'qr_{idx}')
            
            # Generate QR
            qr = qrcode.QRCode(
                version=1,
                error_correction=qrcode.constants.ERROR_CORRECT_H,
                box_size=10,
                border=4,
            )
            qr.add_data(url)
            qr.make(fit=True)
            
            # Save image
            img = qr.make_image(fill_color='black', back_color='white')
            img.save(f'{output_dir}/{filename}.png')
            
            print(f'✓ Generated {idx}: {filename}.png')
    
    print(f'\n✓ All {idx} QR codes generated in {output_dir}')

# Usage
batch_generate_qr('urls.csv', 'output_qrcodes')

With Compression

import zipfile
import os

def create_zip(input_dir, output_zip):
    """Compress QR codes into ZIP"""
    
    with zipfile.ZipFile(output_zip, 'w', zipfile.ZIP_DEFLATED) as zipf:
        for file in os.listdir(input_dir):
            file_path = os.path.join(input_dir, file)
            zipf.write(file_path, arcname=file)
    
    print(f'✓ Created {output_zip}')

# Usage
create_zip('output_qrcodes', 'qrcodes.zip')

Node.js Bulk Generation

const QRCode = require('qrcode');
const csv = require('csv-parser');
const fs = require('fs');
const archiver = require('archiver');

async function batchGenerateQR(csvFile, outputDir) {
  // Create output directory
  fs.mkdirSync(outputDir, { recursive: true });
  
  let count = 0;
  
  return new Promise((resolve, reject) => {
    fs.createReadStream(csvFile)
      .pipe(csv())
      .on('data', async (row) => {
        count++;
        const url = row.url || row.link;
        const filename = row.filename || `qr_${count}`;
        
        await QRCode.toFile(
          `${outputDir}/${filename}.png`,
          url,
          { width: 300, errorCorrectionLevel: 'H' }
        );
        
        console.log(`✓ Generated ${count}: ${filename}.png`);
      })
      .on('end', () => {
        console.log(`✓ All ${count} QR codes generated!`);
        resolve(count);
      })
      .on('error', reject);
  });
}

// Create ZIP archive
function createZipArchive(sourceDir, outputZip) {
  const output = fs.createWriteStream(outputZip);
  const archive = archiver('zip', { zlib: { level: 9 } });
  
  archive.pipe(output);
  archive.directory(sourceDir, false);
  archive.finalize();
  
  console.log(`✓ Created ${outputZip}`);
}

// Usage
(async () => {
  await batchGenerateQR('urls.csv', './qrcodes');
  createZipArchive('./qrcodes', 'qrcodes.zip');
})();

Use Cases

• Inventory Tracking: Generate QR codes for thousands of products
• Marketing Campaigns: Unique codes for each email/mail piece
• Event Check-in: Batch QR codes for attendee registration
• Supply Chain: Track shipments with unique QR per box/pallet
• Product Labels: Generate codes for entire product line
• Loyalty Programs: Unique codes for customer cards
• Print Materials: Codes for direct mail, catalogs, brochures

Performance Optimization

For Large Batches (1,000+)

• Parallel Processing: Generate multiple codes simultaneously
• Image Compression: Use PNG compression to reduce file sizes
• Streaming: Stream to disk immediately, don't hold in memory
• Progress Tracking: Show progress bar during generation

Parallel Python Example

from multiprocessing import Pool
import qrcode

def generate_single_qr(data):
    url, filename, output_dir = data
    qr = qrcode.QRCode(error_correction=qrcode.constants.ERROR_CORRECT_H)
    qr.add_data(url)
    qr.make()
    img = qr.make_image()
    img.save(f'{output_dir}/{filename}.png')
    return filename

# Generate in parallel (4 processes)
with Pool(4) as pool:
    results = pool.map(generate_single_qr, qr_data)

print(f'✓ Generated {len(results)} QR codes')

Best Practices

• Validate URLs: Check URLs are valid before generating
• Error Handling: Skip invalid rows, log errors
• Naming Convention: Use consistent, descriptive filenames
• Test Subset: Generate 10 codes first to verify output
• Backup URLs: Keep original CSV for reference
• Archive Results: ZIP and organize by project/batch

Generate Bulk QR Codes