API Documentation

curl -X POST https://smarterqrcodes.com/api/v1/generate \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content": "https://example.com", "format": "base64"}' \
  -o qrcode.json

curl -X POST https://smarterqrcodes.com/api/v1/generate \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "https://example.com",
    "format": "base64",
    "design": {
      "color_mode": "gradient",
      "gradient_color1": "#667eea",
      "gradient_color2": "#764ba2",
      "gradient_direction": "diagonal"
    }
  }'

import requests
import json
import base64
from pathlib import Path

class SmarterQRClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://smarterqrcodes.com/api/v1"
        self.headers = {
            "X-API-Key": api_key,
            "Content-Type": "application/json"
        }

    def generate_qr(self, content, design=None, name=None):
        """Generate a QR code"""
        data = {
            "content": content,
            "format": "base64"
        }

        if name:
            data["name"] = name
        if design:
            data["design"] = design

        try:
            response = requests.post(
                f"{self.base_url}/generate",
                headers=self.headers,
                json=data
            )
            response.raise_for_status()
            result = response.json()

            if result.get("success"):
                return result
            else:
                raise Exception(result.get("error", "Unknown error"))

        except requests.exceptions.RequestException as e:
            raise Exception(f"API request failed: {str(e)}")

    def save_qr_image(self, image_data, filename):
        """Save base64 image data to file"""
        # Remove data URI prefix
        image_data = image_data.split(',')[1]
        image_bytes = base64.b64decode(image_data)

        Path(filename).write_bytes(image_bytes)

# Usage
client = SmarterQRClient("YOUR_API_KEY")

# Generate basic QR code
result = client.generate_qr(
    content="https://example.com",
    name="My Website QR"
)
print(f"Generated QR Code ID: {result['qr_id']}")
client.save_qr_image(result['image'], "qrcode.png")

# Generate gradient QR code
gradient_design = {
    "color_mode": "gradient",
    "gradient_color1": "#667eea",
    "gradient_color2": "#764ba2",
    "gradient_direction": "diagonal",
    "body_style": "rounded",
    "error_correction": "H"
}

result = client.generate_qr(
    content="https://example.com",
    design=gradient_design,
    name="Gradient QR"
)
client.save_qr_image(result['image'], "gradient_qr.png")

class SmarterQRClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://smarterqrcodes.com/api/v1';
  }

  async generateQR(content, design = null, name = null) {
    const data = {
      content,
      format: 'base64'
    };

    if (name) data.name = name;
    if (design) data.design = design;

    try {
      const response = await fetch(`${this.baseUrl}/generate`, {
        method: 'POST',
        headers: {
          'X-API-Key': this.apiKey,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(data)
      });

      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.error || `HTTP ${response.status}`);
      }

      const result = await response.json();

      if (result.success) {
        return result;
      } else {
        throw new Error(result.error || 'Unknown error');
      }
    } catch (error) {
      console.error('QR generation failed:', error);
      throw error;
    }
  }

  async generateSTL(content, stlOptions = {}) {
    const data = {
      data: content,
      ...stlOptions
    };

    const response = await fetch(`${this.baseUrl}/generate-qr-stl`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(data)
    });

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }

    return response.blob();
  }
}

// Usage Examples
const client = new SmarterQRClient('YOUR_API_KEY');

// Generate basic QR code
async function createBasicQR() {
  try {
    const result = await client.generateQR('https://example.com', null, 'Website QR');
    console.log('QR Code ID:', result.qr_id);

    // Display in img tag
    document.getElementById('qrImage').src = result.image;
  } catch (error) {
    console.error('Failed to generate QR:', error);
  }
}

// Generate gradient QR code
async function createGradientQR() {
  const design = {
    color_mode: 'gradient',
    gradient_color1: '#667eea',
    gradient_color2: '#764ba2',
    gradient_direction: 'diagonal',
    body_style: 'circle',
    error_correction: 'H'
  };

  try {
    const result = await client.generateQR('https://example.com', design, 'Gradient QR');
    document.getElementById('gradientQR').src = result.image;
  } catch (error) {
    console.error('Failed to generate gradient QR:', error);
  }
}

// Generate 3D STL file
async function create3DQR() {
  try {
    const stlBlob = await client.generateSTL('https://example.com', {
      stl_height: 3.0,
      stl_base_height: 1.0,
      stl_max_dimension: 100.0
    });

    // Create download link
    const url = URL.createObjectURL(stlBlob);
    const a = document.createElement('a');
    a.href = url;
    a.download = 'qrcode.stl';
    a.click();
  } catch (error) {
    console.error('Failed to generate STL:', error);
  }
}

// Run examples
createBasicQR();
createGradientQR();

apiKey = $apiKey;
    }

    public function generateQR($content, $design = null, $name = null) {
        $data = [
            'content' => $content,
            'format' => 'base64'
        ];

        if ($name !== null) {
            $data['name'] = $name;
        }

        if ($design !== null) {
            $data['design'] = $design;
        }

        $ch = curl_init($this->baseUrl . '/generate');
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
            'Content-Type: application/json'
        ]);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode !== 200) {
            $error = json_decode($response, true);
            throw new Exception($error['error'] ?? 'API request failed');
        }

        $result = json_decode($response, true);

        if (!$result['success']) {
            throw new Exception($result['error'] ?? 'Unknown error');
        }

        return $result;
    }

    public function saveQRImage($imageData, $filename) {
        // Remove data URI prefix
        $parts = explode(',', $imageData);
        $imageData = $parts[1];
        $imageBytes = base64_decode($imageData);

        return file_put_contents($filename, $imageBytes);
    }
}

// Usage
try {
    $client = new SmarterQRClient('YOUR_API_KEY');

    // Generate basic QR code
    $result = $client->generateQR(
        'https://example.com',
        null,
        'Website QR'
    );
    echo "Generated QR Code ID: " . $result['qr_id'] . "\n";
    $client->saveQRImage($result['image'], 'qrcode.png');

    // Generate gradient QR code
    $gradientDesign = [
        'color_mode' => 'gradient',
        'gradient_color1' => '#667eea',
        'gradient_color2' => '#764ba2',
        'gradient_direction' => 'diagonal',
        'body_style' => 'rounded',
        'error_correction' => 'H'
    ];

    $result = $client->generateQR(
        'https://example.com',
        $gradientDesign,
        'Gradient QR'
    );
    $client->saveQRImage($result['image'], 'gradient_qr.png');

    echo "QR codes generated successfully!\n";

} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

?>

require 'net/http'
require 'json'
require 'base64'

class SmarterQRClient
  def initialize(api_key)
    @api_key = api_key
    @base_url = 'https://smarterqrcodes.com/api/v1'
  end

  def generate_qr(content, design: nil, name: nil)
    uri = URI("#{@base_url}/generate")

    data = {
      content: content,
      format: 'base64'
    }
    data[:name] = name if name
    data[:design] = design if design

    request = Net::HTTP::Post.new(uri)
    request['X-API-Key'] = @api_key
    request['Content-Type'] = 'application/json'
    request.body = data.to_json

    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end

    result = JSON.parse(response.body)

    unless response.code == '200' && result['success']
      raise "API Error: #{result['error'] || 'Unknown error'}"
    end

    result
  end

  def save_qr_image(image_data, filename)
    # Remove data URI prefix
    image_data = image_data.split(',')[1]
    image_bytes = Base64.decode64(image_data)

    File.open(filename, 'wb') do |file|
      file.write(image_bytes)
    end
  end
end

# Usage
begin
  client = SmarterQRClient.new('YOUR_API_KEY')

  # Generate basic QR code
  result = client.generate_qr(
    'https://example.com',
    name: 'Website QR'
  )
  puts "Generated QR Code ID: #{result['qr_id']}"
  client.save_qr_image(result['image'], 'qrcode.png')

  # Generate gradient QR code
  gradient_design = {
    color_mode: 'gradient',
    gradient_color1: '#667eea',
    gradient_color2: '#764ba2',
    gradient_direction: 'diagonal',
    body_style: 'circle',
    error_correction: 'H'
  }

  result = client.generate_qr(
    'https://example.com',
    design: gradient_design,
    name: 'Gradient QR'
  )
  client.save_qr_image(result['image'], 'gradient_qr.png')

  puts 'QR codes generated successfully!'

rescue => e
  puts "Error: #{e.message}"
end