Download QR Code

const fetch = require('node-fetch');
const fs = require('fs');

async function generateAndSaveQRCode(outputPath) {
  const response = await fetch('https://jmpy.me/api/v1/qr-codes/generate', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      content_type: 'url',
      content_data: { url: 'https://example.com' },
      visual_settings: { size: 500 }
    })
  });

  const data = await response.json();
  const dataURL = data.data.qr_code_data;

  // Extract base64 data (remove data URL prefix)
  const base64Data = dataURL.replace(/^data:image\/\w+;base64,/, '');
  
  // Convert to Buffer and save
  const buffer = Buffer.from(base64Data, 'base64');
  fs.writeFileSync(outputPath, buffer);
  
  console.log(`QR code saved to: ${outputPath}`);
  console.log(`File size: ${buffer.length} bytes`);
  
  return outputPath;
}

// Usage
generateAndSaveQRCode('./my-qrcode.png');

import requests
import base64
from io import BytesIO
from PIL import Image  # pip install Pillow

def generate_and_save_qr(output_path, format='PNG'):
    """Generate QR code and save in specified format."""
    
    response = requests.post(
        'https://jmpy.me/api/v1/qr-codes/generate',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
        },
        json={
            'content_type': 'url',
            'content_data': {'url': 'https://example.com'},
            'visual_settings': {'size': 500}
        }
    )
    
    data = response.json()
    data_url = data['data']['qr_code_data']
    
    # Extract base64 data
    header, encoded = data_url.split(',', 1)
    image_data = base64.b64decode(encoded)
    
    # Save as PNG directly
    if format.upper() == 'PNG':
        with open(output_path, 'wb') as f:
            f.write(image_data)
    else:
        # Convert to other formats using Pillow
        image = Image.open(BytesIO(image_data))
        image.save(output_path, format=format.upper())
    
    print(f"QR code saved to: {output_path}")
    return output_path

# Save as PNG
generate_and_save_qr('qrcode.png', 'PNG')

# Save as JPEG
generate_and_save_qr('qrcode.jpg', 'JPEG')

# Save as WebP
generate_and_save_qr('qrcode.webp', 'WEBP')

<?php
$client = new GuzzleHttp\Client();

$response = $client->request('POST', 'https://jmpy.me/api/v1/qr-codes/generate', [
    'headers' => [
        'Authorization' => 'Bearer YOUR_API_KEY',
        'Content-Type' => 'application/json'
    ],
    'json' => [
        'content_type' => 'url',
        'content_data' => ['url' => 'https://example.com'],
        'visual_settings' => ['size' => 500]
    ]
]);

$data = json_decode($response->getBody(), true);
$dataUrl = $data['data']['qr_code_data'];

// Extract and decode base64 data
$parts = explode(',', $dataUrl);
$imageData = base64_decode($parts[1]);

// Save to file
file_put_contents('qrcode.png', $imageData);
echo "QR code saved to qrcode.png\n";

// To convert to other formats, use GD or Imagick
// Example with GD:
$image = imagecreatefromstring($imageData);
imagejpeg($image, 'qrcode.jpg', 90);
imagedestroy($image);
echo "JPEG version saved to qrcode.jpg\n";
?>

package main

import (
    "bytes"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "strings"
)

func main() {
    // Generate QR code
    payload := map[string]interface{}{
        "content_type": "url",
        "content_data": map[string]string{
            "url": "https://example.com",
        },
        "visual_settings": map[string]int{
            "size": 500,
        },
    }
    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://jmpy.me/api/v1/qr-codes/generate", bytes.NewBuffer(jsonData))
    req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Add("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    
    data := result["data"].(map[string]interface{})
    dataURL := data["qr_code_data"].(string)

    // Extract base64 data
    parts := strings.Split(dataURL, ",")
    imageData, _ := base64.StdEncoding.DecodeString(parts[1])

    // Save to file
    ioutil.WriteFile("qrcode.png", imageData, 0644)
    fmt.Println("QR code saved to qrcode.png")
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.URI;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import org.json.JSONObject;

public class QRCodeDownload {
    public static void main(String[] args) throws Exception {
        String jsonPayload = """
        {
            "content_type": "url",
            "content_data": {"url": "https://example.com"},
            "visual_settings": {"size": 500}
        }""";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://jmpy.me/api/v1/qr-codes/generate"))
            .header("Authorization", "Bearer YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build();

        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
        
        JSONObject result = new JSONObject(response.body());
        String dataURL = result.getJSONObject("data").getString("qr_code_data");
        
        // Extract base64 data
        String base64Data = dataURL.split(",")[1];
        byte[] imageBytes = Base64.getDecoder().decode(base64Data);
        
        // Save to file
        Files.write(Path.of("qrcode.png"), imageBytes);
        System.out.println("QR code saved to qrcode.png");
    }
}