Api Rest Documentazione

Indice Documentazione API-Rest

Esempi di integrazione:

NodeJs
Python
PHP
Ruby
TypeScript
Swift
GO (Golang)
C++
C#
Java
Asp Vb.Net
HTML/JavaScript (Client-Side)

Response API

Genera un QR Code Statico (Testo o URL)

Questo endpoint genera un QR code statico a partire da un testo o un URL. È ideale per biglietti da visita, link a siti web, informazioni di contatto o qualsiasi altro dato che non necessita di essere aggiornato in futuro.

Richiesta:

URL: https://www.qrcodegenerate.it/api/v1/qrcode/generate-static

Metodo: POST/GET

Parametri del Body (JSON) / URL

content Stringa Obbligatorio

Il testo o l'URL da codificare nel QRcode.

"https://www.tuosito.it"

format Stringa Opzionale

Il formato dell'immagine desiderato. I formati supportati sono png, jpeg, webp, svg, e base64url. Default: png.

"jpeg"

size Numero Opzionale

La dimensione del QR code in pixel. Default: 200.

300

color Oggetto Opzionale

I colori di primo piano e di sfondo del QR code.

{ "dark": "#000000", "light":
                  "#FFFFFF" }

logoUrl Stringa Opzionale

URL di un'immagine da inserire al centro del QR code. Funziona solo con i formati PNG, JPEG e WebP.

"https://www.logo.it/logo.png"

Esempi di Codice in Node.js

open

Qui di seguito trovi gli esempi di codice per integrare la nostra API nel tuo progetto Node.js.

Esempio con Richiesta POST:

La richiesta POST è la soluzione raccomandata perché consente di inviare un oggetto JSON nel corpo della richiesta, rendendo facile includere parametri complessi come i colori, gli oggetti logoUrl e le dimensioni, senza limiti di lunghezza dell'URL.

Indice

const apiKey = 'la_tua_api_key';
const endpoint = 'https://qrcodegenerate.it/api/v1/qrcode/generate-static';

const data = {
    content: 'https://www.tuosito.it',
    format: 'png',
    size: 200,
    color: { dark: '#000000', light: '#FFFFFF' },
    logoUrl: 'https://il-tuo-dominio.com/logo.png' // Aggiungi il parametro logoUrl
};

async function generateQRCodePost() {
    try {
        const response = await fetch(endpoint, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'x-api-key': apiKey
            },
            body: JSON.stringify(data)
        });

        if (!response.ok) {
            const error = await response.json();
            throw new Error(`Errore HTTP! Status: ${response.status}, Messaggio: ${error.message}`);
        }

        const imageBlob = await response.blob();
        const imageUrl = URL.createObjectURL(imageBlob);
        console.log('URL dell\'immagine creata:', imageUrl);
    } catch (error) {
        console.error('Si è verificato un errore:', error);
    }
}

generateQRCodePost();

Esempio con Richiesta GET

La richiesta GET è più adatta per i casi d'uso più semplici, in cui i parametri possono essere codificati facilmente nell'URL

Nota: A causa delle limitazioni di formattazione dell'URL, i parametri di tipo oggetto (es. color) non possono essere inclusi in una richiesta GET.

Indice

const apiKey = 'la_tua_api_key';
const endpointBase = 'https://www.qrcodegenerate.it/api/v1/qrcode/generate-static';

const content = 'https://www.tuosito.it';
const format = 'svg'; // Scegli un formato supportato

// Crea i parametri della query string
const params = new URLSearchParams({
    content: content,
    format: format,
    size: 300
});

const finalUrl = `${endpointBase}?${params.toString()}`;

async function generateQRCodeGet() {
    try {
        const response = await fetch(finalUrl, {
            method: 'GET',
            headers: {
                'x-api-key': apiKey
            }
        });

        if (!response.ok) {
            const error = await response.json();
            throw new Error(`Errore HTTP! Status: ${response.status}, Messaggio: ${error.message}`);
        }

        const svgText = await response.text();
        console.log('Codice SVG ricevuto:', svgText);
        
    } catch (error) {
        console.error('Si è verificato un errore:', error);
    }
}

generateQRCodeGet();

Esempi di Codice in Python

open

Per eseguire questi esempi, assicurati di aver installato la libreria requests. Se non l'hai già fatto, puoi installarla facilmente con pip:

pip install requests

Esempio con Richiesta POST

La richiesta POST è la soluzione più robusta per generare QR code con la nostra API, perché ti permette di inviare tutti i parametri necessari (incluso il campo color e logoUrl) in un corpo JSON strutturato. Questo è l'approccio consigliato per sfruttare appieno le funzionalità di personalizzazione.

Indice

import requests
import json

api_key = 'la_tua_api_key'
endpoint = 'https://https://qrcodegenerate.it/api/v1/qrcode/generate-static'

data = {
    "content": "https://www.tuosito.it",
    "format": "png",
    "size": 200,
    "color": { "dark": "#000000", "light": "#FFFFFF" },
    "logoUrl": "https://il-tuo-dominio.com/logo.png"
}

headers = {
    'Content-Type': 'application/json',
    'x-api-key': api_key
}

try:
    response = requests.post(endpoint, headers=headers, data=json.dumps(data))
    response.raise_for_status()  # Solleva un'eccezione se la richiesta fallisce

    # Salva l'immagine generata in un file
    with open('qrcode.png', 'wb') as f:
        f.write(response.content)
    
    print("QR Code generato e salvato come 'qrcode.png'")
    
except requests.exceptions.RequestException as e:
    print(f"Errore nella richiesta: {e}")
except Exception as e:
    print(f"Si è verificato un errore inaspettato: {e}")

Esempio con Richiesta GET

La richiesta GET è ideale per generare QR code più semplici, dove i parametri possono essere inclusi direttamente nell'URL.

Nota bene: Non è possibile passare parametri di tipo oggetto (color) o array in una richiesta GET.

Indice

import requests

api_key = 'la_tua_api_key'
endpoint = 'https://https://qrcodegenerate.it/api/v1/qrcode/generate-static'

params = {
    "content": "https://www.tuosito.it",
    "format": "svg",
    "size": 300
}

headers = {
    'x-api-key': api_key
}

try:
    response = requests.get(endpoint, headers=headers, params=params)
    response.raise_for_status()  # Solleva un'eccezione se la richiesta fallisce

    # Se il formato è SVG, salva il testo
    with open('qrcode.svg', 'w') as f:
        f.write(response.text)
    
    print("QR Code generato e salvato come 'qrcode.svg'")

except requests.exceptions.RequestException as e:
    print(f"Errore nella richiesta: {e}")
except Exception as e:
    print(f"Si è verificato un errore inaspettato: {e}")

Esempi di Codice in PHP

open

Ecco come puoi integrare l'API per la generazione di QR code nei tuoi progetti PHP.

Esempio con Richiesta POST

La richiesta POST è il modo migliore per inviare parametri complessi e strutturati in un corpo JSON, come i colori o l'URL del logo. Questo è l'approccio consigliato per sfruttare appieno le funzionalità di personalizzazione dell'API.

Indice

<?php

$apiKey = 'la_tua_api_key';
$endpoint = 'https://qrcodegenerate.it/api/v1/qrcode/generate-static';

$data = [
    'content' => 'https://www.tuosito.it',
    'format' => 'png',
    'size' => 200,
    'color' => [ 'dark' => '#000000', 'light' => '#FFFFFF' ],
    'logoUrl' => 'https://il-tuo-dominio.com/logo.png'
];

$options = [
    'http' => [
        'header'  => "Content-type: application/json\r\n" .
                     "x-api-key: $apiKey\r\n",
        'method'  => 'POST',
        'content' => json_encode($data),
    ],
];

$context  = stream_context_create($options);
$response = file_get_contents($endpoint, false, $context);

if ($response === FALSE) {
    // Gestione dell'errore. Potrebbe essere necessario un controllo più granulare
    // usando librerie come cURL per i codici di errore HTTP.
    echo 'Si è verificato un errore nella richiesta.';
} else {
    // Se la risposta è un'immagine, la salvi in un file
    file_put_contents('qrcode.png', $response);
    echo 'QR Code generato e salvato come "qrcode.png".';
}
?>

Esempio con Richiesta GET

La richiesta **GET** è più semplice e adatta a URL o testi che non richiedono opzioni di personalizzazione avanzate. I parametri vengono passati direttamente nell'URL come query string.

**Nota:** Questo metodo **non supporta** l'invio di parametri complessi come gli oggetti `color`.

Indice

<?php

$apiKey = 'la_tua_api_key';
$endpoint = '[https://qrcodegenerate.it/api/v1/qrcode/generate-static](https://qrcodegenerate.it/api/v1/qrcode/generate-static)';

$params = [
    'content' => '[https://www.tuosito.it](https://www.tuosito.it)',
    'format' => 'svg',
    'size' => 300,
];

// Costruisci l'URL finale con i parametri
$queryString = http_build_query($params);
$finalUrl = $endpoint . '?' . $queryString;

$options = [
    'http' => [
        'header' => "x-api-key: $apiKey\r\n",
        'method' => 'GET',
    ],
];

$context = stream_context_create($options);
$response = @file_get_contents($finalUrl, false, $context);

if ($response === FALSE) {
    // Gestione dell'errore
    echo 'Si è verificato un errore nella richiesta GET.';
} else {
    // Se il formato è SVG, salva il testo
    file_put_contents('qrcode.svg', $response);
    echo 'QR Code generato e salvato come "qrcode.svg".';
}
?>

Esempi di Codice in Ruby

open

Esempio con Richiesta POST

La richiesta POST è la soluzione ideale per inviare un corpo JSON strutturato, permettendo di utilizzare tutti i parametri di personalizzazione dell'API, come i colori e il logoUrl. Questo è il metodo raccomandato per un utilizzo completo e flessibile della tua API.

Indice

# frozen_string_literal: true

require 'net/http'
require 'uri'
require 'json'

api_key = 'la_tua_api_key'
endpoint = URI('https://qrcode.antonioterlizzi.it/api/v1/qrcode/generate-static')

data = {
  content: 'https://www.tuosito.it',
  format: 'png',
  size: 200,
  color: { dark: '#000000', light: '#FFFFFF' },
  logoUrl: 'https://il-tuo-dominio.com/logo.png'
}

# Creazione della richiesta HTTP
http = Net::HTTP.new(endpoint.host, endpoint.port)
http.use_ssl = true

request = Net::HTTP::Post.new(endpoint.path, 'Content-Type' => 'application/json', 'x-api-key' => api_key)
request.body = data.to_json

begin
  response = http.request(request)

  if response.is_a?(Net::HTTPSuccess)
    # Se la richiesta ha avuto successo, salva l'immagine
    File.open('qrcode.png', 'wb') do |f|
      f.write(response.body)
    end
    puts 'QR Code generato e salvato come "qrcode.png".'
  else
    # Gestione dell'errore
    error_data = JSON.parse(response.body) rescue { message: response.body }
    puts "Errore HTTP! Status: #{response.code}, Messaggio: #{error_data['message']}"
  end
rescue StandardError => e
  puts "Si è verificato un errore: #{e.message}"
end

Esempio con Richiesta GET

La richiesta GET è più adatta per i casi d'uso semplici, dove i parametri possono essere inclusi direttamente nell'URL.

Nota: Questo metodo non supporta l'invio di parametri complessi di tipo oggetto (color).

Indice

# frozen_string_literal: true

require 'net/http'
require 'uri'

api_key = 'la_tua_api_key'
endpoint_base = 'https://qrcodegenerate.it/api/v1/qrcode/generate-static'

params = {
  content: 'https://www.tuosito.it',
  format: 'svg',
  size: 300
}

# Costruzione dell'URL finale con i parametri
final_url = URI(endpoint_base)
final_url.query = URI.encode_www_form(params)

http = Net::HTTP.new(final_url.host, final_url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(final_url.request_uri, 'x-api-key' => api_key)

begin
  response = http.request(request)

  if response.is_a?(Net::HTTPSuccess)
    # Se il formato è SVG, salva il testo
    File.open('qrcode.svg', 'w') do |f|
      f.write(response.body)
    end
    puts 'QR Code generato e salvato come "qrcode.svg".'
  else
    puts "Errore HTTP! Status: #{response.code}, Messaggio: #{response.body}"
  end
rescue StandardError => e
  puts "Si è verificato un errore: #{e.message}"
end

Esempi di Codice in TypeScript

open

Per eseguire questi esempi, dovrai avere Node.js installato e configurato con TypeScript. Puoi installare ts-node per eseguire i file TypeScript direttamente, senza doverli compilare in JavaScript prima.

npm install -g typescript
            ts-node

Esempio con Richiesta POST

La richiesta POST è il metodo preferito per la generazione di QR code, in quanto consente di inviare parametri complessi come oggetti JSON nel corpo della richiesta.

Indice
          
// Esempio per Node.js con TypeScript
// Esegui con: ts-node tuofile.ts
import fetch from 'node-fetch'; // Se usi versioni di Node.js < 18

async function generateQRCodePost(): Promise {
    const apiKey: string = 'la_tua_api_key';
    const endpoint: string = 'https://qrcodegenerate.it/api/v1/qrcode/generate-static';

    const data = {
        content: 'https://www.tuosito.it',
        format: 'png',
        size: 200,
        color: { dark: '#000000', light: '#FFFFFF' },
        logoUrl: 'https://il-tuo-dominio.com/logo.png'
    };

    try {
        const response = await fetch(endpoint, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'x-api-key': apiKey
            },
            body: JSON.stringify(data)
        });

        if (!response.ok) {
            const errorText: string = await response.text();
            throw new Error(`Errore HTTP! Status: ${response.status}, Messaggio: ${errorText}`);
        }

        const imageBlob: Buffer = await response.buffer();
        // In Node.js, puoi salvare il buffer direttamente in un file
        require('fs').writeFileSync('qrcode.png', imageBlob);
        console.log("QR Code generato e salvato come 'qrcode.png'.");

    } catch (error) {
        console.error('Si è verificato un errore:', (error as Error).message);
    }
}

generateQRCodePost();

Esempio con Richiesta GET

La richiesta GET è più semplice e adatta per i casi d'uso dove i parametri sono inclusi direttamente nell'URL.

Nota: Questo metodo non supporta l'invio di parametri complessi di tipo oggetto (color).

Indice
        
// Esempio per Node.js con TypeScript
// Esegui con: ts-node tuofile.ts
import fetch from 'node-fetch'; // Se usi versioni di Node.js < 18

async function generateQRCodeGet(): Promise {
    const apiKey: string = 'la_tua_api_key';
    const endpointBase: string = 'https://qrcodegenerate.it/api/v1/qrcode/generate-static';

    const params = new URLSearchParams({
        content: 'https://www.tuosito.it',
        format: 'svg',
        size: '300'
    });

    const finalUrl: string = `${endpointBase}?${params.toString()}`;

    try {
        const response = await fetch(finalUrl, {
            method: 'GET',
            headers: {
                'x-api-key': apiKey
            }
        });

        if (!response.ok) {
            const errorText: string = await response.text();
            throw new Error(`Errore HTTP! Status: ${response.status}, Messaggio: ${errorText}`);
        }

        const svgText: string = await response.text();
        // Salva il testo SVG in un file
        require('fs').writeFileSync('qrcode.svg', svgText);
        console.log("QR Code generato e salvato come 'qrcode.svg'.");

    } catch (error) {
        console.error('Si è verificato un errore:', (error as Error).message);
    }
}

generateQRCodeGet();

Esempi di Codice in Swift

open

Come concordato, passiamo a Swift, il linguaggio di programmazione di Apple. Per gli esempi, utilizzeremo la classe nativa URLSession, l'approccio standard per le richieste di rete su piattaforme Apple (iOS, macOS, watchOS, tvOS). Questo approccio non richiede librerie esterne.

Richiesta POST

Indice

import Foundation

func generateQRCodePost() {
    let apiKey = "la_tua_api_key"
    let urlString = "https://qrcodegenerate.it/api/v1/qrcode/generate-static"
    guard let url = URL(string: urlString) else {
        print("URL non valido")
        return
    }

    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.addValue("application/json", forHTTPHeaderField: "Content-Type")
    request.addValue(apiKey, forHTTPHeaderField: "x-api-key")

    let parameters: [String: Any] = [
        "content": "https://www.tuosito.it",
        "format": "png",
        "size": 200,
        "color": [ "dark": "#000000", "light": "#FFFFFF" ],
        "logoUrl": "https://il-tuo-dominio.com/logo.png"
    ]
    
    do {
        request.httpBody = try JSONSerialization.data(withJSONObject: parameters, options: .prettyPrinted)
    } catch let error {
        print(error.localizedDescription)
        return
    }

    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        guard let data = data, error == nil else {
            print(error?.localizedDescription ?? "Errore di rete")
            return
        }

        if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode != 200 {
            let errorMessage = String(data: data, encoding: .utf8) ?? "Errore sconosciuto"
            print("Errore HTTP! Status: \(httpResponse.statusCode), Messaggio: \(errorMessage)")
            return
        }
        
        // Salva l'immagine in un file o usala nella UI
        let fileManager = FileManager.default
        let documentsPath = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first!
        let filePath = documentsPath.appendingPathComponent("qrcode.png")
        
        do {
            try data.write(to: filePath)
            print("QR Code generato e salvato in \(filePath.path)")
        } catch {
            print("Impossibile salvare il file: \(error)")
        }
    }
    task.resume()
}

// Chiamare la funzione per eseguire la richiesta
// generateQRCodePost()

Richiesta GET

La richiesta GET è ideale per generare QR code semplici, dove tutti i parametri possono essere inclusi direttamente nell'URL.

Nota: Questo metodo non supporta l'invio di parametri complessi di tipo oggetto (color).

Indice

          import Foundation

func generateQRCodeGet() {
    let apiKey = "la_tua_api_key"
    var urlComponents = URLComponents(string: "https://qrcodegenerate.it/api/v1/qrcode/generate-static")!

    urlComponents.queryItems = [
        URLQueryItem(name: "content", value: "https://www.tuosito.it"),
        URLQueryItem(name: "format", value: "svg"),
        URLQueryItem(name: "size", value: "300")
    ]
    
    guard let url = urlComponents.url else {
        print("URL non valido")
        return
    }

    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.addValue(apiKey, forHTTPHeaderField: "x-api-key")

    let task = URLSession.shared.dataTask(with: request) { data, response, error in
        guard let data = data, error == nil else {
            print(error?.localizedDescription ?? "Errore di rete")
            return
        }
        
        if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode != 200 {
            let errorMessage = String(data: data, encoding: .utf8) ?? "Errore sconosciuto"
            print("Errore HTTP! Status: \(httpResponse.statusCode), Messaggio: \(errorMessage)")
            return
        }
        
        // Se il formato è SVG, salva il testo
        if let svgString = String(data: data, encoding: .utf8) {
            print("Codice SVG ricevuto:")
            print(svgString)
            // Puoi salvare il file come 'qrcode.svg'
        }
    }
    task.resume()
}

// Chiamare la funzione per eseguire la richiesta
// generateQRCodeGet()

Esempi di Codice in Go (Golang)

open

Per gli esempi in Go, utilizzeremo la libreria standard net/http per le richieste, che è l'approccio nativo e non richiede l'installazione di pacchetti esterni. Questo rende il codice snello e facilmente integrabile.

Richiesta POST

La richiesta POST è il metodo raccomandato per la generazione di QR code, poiché permette di inviare parametri complessi (come oggetti JSON per colori e logo) nel corpo della richiesta.

Indice

package main

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

func main() {
	apiKey := "la_tua_api_key"
	endpoint := "https://qrcodegenerate.it/api/v1/qrcode/generate-static"

	// Definisci la struttura dei dati da inviare
	data := map[string]interface{}{
		"content":   "https://www.tuosito.it",
		"format":    "png",
		"size":      200,
		"color":     map[string]string{"dark": "#000000", "light": "#FFFFFF"},
		"logoUrl":   "https://il-tuo-dominio.com/logo.png",
	}

	jsonData, err := json.Marshal(data)
	if err != nil {
		fmt.Println("Errore nel marshalling del JSON:", err)
		return
	}

	req, err := http.NewRequest("POST", endpoint, bytes.NewBuffer(jsonData))
	if err != nil {
		fmt.Println("Errore nella creazione della richiesta:", err)
		return
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-api-key", apiKey)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Errore nella richiesta HTTP:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := ioutil.ReadAll(resp.Body)
		fmt.Printf("Errore HTTP! Status: %d, Messaggio: %s\n", resp.StatusCode, string(body))
		return
	}

	// Salva l'immagine in un file
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Errore nella lettura del corpo della risposta:", err)
		return
	}

	err = ioutil.WriteFile("qrcode.png", body, 0644)
	if err != nil {
		fmt.Println("Errore nel salvataggio del file:", err)
		return
	}

	fmt.Println("QR Code generato e salvato come 'qrcode.png'.")
}

Richiesta GET

La richiesta GET è più adatta per generare QR code semplici, dove tutti i parametri possono essere inclusi direttamente nell'URL come query string. Questo metodo non supporta parametri di tipo oggetto come color.

Indice
          
package main

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"os"
)

func main() {
	apiKey := "la_tua_api_key"
	endpoint := "https://qrcodegenerate.it/api/v1/qrcode/generate-static"

	// Costruisci i parametri della query string
	params := url.Values{}
	params.Add("content", "https://www.tuosito.it")
	params.Add("format", "svg")
	params.Add("size", "300")

	finalURL := fmt.Sprintf("%s?%s", endpoint, params.Encode())

	req, err := http.NewRequest("GET", finalURL, nil)
	if err != nil {
		fmt.Println("Errore nella creazione della richiesta:", err)
		return
	}

	req.Header.Set("x-api-key", apiKey)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Errore nella richiesta HTTP:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := ioutil.ReadAll(resp.Body)
		fmt.Printf("Errore HTTP! Status: %d, Messaggio: %s\n", resp.StatusCode, string(body))
		return
	}

	// Salva il file SVG
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Errore nella lettura del corpo della risposta:", err)
		return
	}

	err = ioutil.WriteFile("qrcode.svg", body, 0644)
	if err != nil {
		fmt.Println("Errore nel salvataggio del file:", err)
		return
	}

	fmt.Println("QR Code generato e salvato come 'qrcode.svg'.")
}

Esempi C++ con libcurl

open

Per utilizzare questi esempi, assicurati che libcurl sia installata sul sistema e che il programma sia compilato e linkato correttamente. Ad esempio, su Linux, il comando di compilazione potrebbe essere simile a questo:

g++ your_file.cpp -o your_program -lcurl

Richiesta POST

Questo esempio mostra come inviare un corpo JSON in una richiesta POST per generare un QR code con opzioni di personalizzazione avanzate.

Indice

#include 
#include 
#include 

// Callback per salvare la risposta
size_t write_callback(void* contents, size_t size, size_t nmemb, void* userp) {
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();
    if (curl) {
        // Endpoint e dati JSON
        const char* endpoint = "https://qrcodegenerate.it/api/v1/qrcode/generate-static";
        const char* post_data = "{\"content\":\"https://www.tuosito.it\",\"format\":\"png\",\"size\":200,\"color\":{\"dark\":\"#000000\",\"light\":\"#FFFFFF\"}}";
        const char* apiKey = "la_tua_api_key";

        // Impostazioni della richiesta
        curl_easy_setopt(curl, CURLOPT_URL, endpoint);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, post_data);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        // Impostazioni degli header
        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Content-Type: application/json");
        std::string apiKeyHeader = "x-api-key: " + std::string(apiKey);
        headers = curl_slist_append(headers, apiKeyHeader.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

        // Esegui la richiesta
        res = curl_easy_perform(curl);
        if (res != CURLE_OK) {
            std::cerr << "curl_easy_perform() fallito: " << curl_easy_strerror(res) << std::endl;
        } else {
            // Qui 'readBuffer' contiene l'immagine (PNG) come dati binari
            // Puoi salvarla su un file
            FILE* fp = fopen("qrcode.png", "wb");
            if (fp) {
                fwrite(readBuffer.c_str(), 1, readBuffer.size(), fp);
                fclose(fp);
                std::cout << "QR Code generato e salvato come 'qrcode.png'." << std::endl;
            } else {
                std::cerr << "Impossibile creare il file." << std::endl;
            }
        }

        // Pulizia
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    return 0;
}

Esempio con Richiesta GET

Questo esempio mostra come costruire una richiesta GET con i parametri dell'URL per generare un QR code SVG.

Indice

#include 
#include 
#include 

// Callback per salvare la risposta
size_t write_callback(void* contents, size_t size, size_t nmemb, void* userp) {
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();
    if (curl) {
        // Costruisci l'URL con i parametri
        std::string url = "https://qrcodegenerate.it/api/v1/qrcode/generate-static";
        std::string params = "content=https://www.tuosito.it&format=svg&size=300";
        std::string finalUrl = url + "?" + params;
        const char* apiKey = "la_tua_api_key";

        // Impostazioni della richiesta
        curl_easy_setopt(curl, CURLOPT_URL, finalUrl.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        // Impostazione dell'header
        struct curl_slist* headers = NULL;
        std::string apiKeyHeader = "x-api-key: " + std::string(apiKey);
        headers = curl_slist_append(headers, apiKeyHeader.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

        // Esegui la richiesta
        res = curl_easy_perform(curl);
        if (res != CURLE_OK) {
            std::cerr << "curl_easy_perform() fallito: " << curl_easy_strerror(res) << std::endl;
        } else {
            // 'readBuffer' contiene il codice SVG come testo
            std::cout << "Codice SVG ricevuto:" << std::endl << readBuffer << std::endl;
            
            // Puoi salvare il testo SVG in un file
            FILE* fp = fopen("qrcode.svg", "w");
            if (fp) {
                fwrite(readBuffer.c_str(), 1, readBuffer.size(), fp);
                fclose(fp);
            }
        }

        // Pulizia
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    return 0;
}

Esempi di Codice in C#

open

Per gli esempi in questo linguaggio, utilizzeremo la classe nativa HttpClient, che è la soluzione moderna e standard per le richieste HTTP in .NET. Questo approccio è asincrono e non richiede librerie di terze parti per le funzionalità di base.

Richiesta POST

La richiesta POST è il metodo raccomandato per inviare dati complessi (come oggetti JSON) nel corpo della richiesta. Questo ti consente di usare tutte le opzioni di personalizzazione dell'API, come i colori e l'URL del logo.

Indice

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using Newtonsoft.Json; // Richiede il pacchetto NuGet Newtonsoft.Json

public class QrCodeGenerator
{
    public static async Task GenerateQRCodePostAsync()
    {
        string apiKey = "la_tua_api_key";
        string endpoint = "https://qrcodegenerate.it/api/v1/qrcode/generate-static";

        // Dati JSON per la richiesta
        var data = new
        {
            content = "https://www.tuosito.it",
            format = "png",
            size = 200,
            color = new { dark = "#000000", light = "#FFFFFF" },
            logoUrl = "https://il-tuo-dominio.com/logo.png"
        };
        
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("x-api-key", apiKey);

            try
            {
                var response = await client.PostAsync(endpoint, content);
                response.EnsureSuccessStatusCode(); // Solleva un'eccezione in caso di errore HTTP

                // Leggi i byte dell'immagine dalla risposta
                var imageBytes = await response.Content.ReadAsByteArrayAsync();

                // Salva l'immagine su un file
                await File.WriteAllBytesAsync("qrcode.png", imageBytes);
                Console.WriteLine("QR Code generato e salvato come 'qrcode.png'.");
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine($"Errore nella richiesta: {e.Message}");
            }
        }
    }
}

Richiesta GET

La richiesta GET è più semplice e adatta per i casi d'uso dove tutti i parametri possono essere inclusi nell'URL come query string. Questo metodo non supporta parametri di tipo oggetto come color.

Indice

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;
using System.Web; // Richiede un riferimento a System.Web o l'uso di HttpUtility

public class QrCodeGeneratorGet
{
    public static async Task GenerateQRCodeGetAsync()
    {
        string apiKey = "la_tua_api_key";
        string endpoint = "https://qrcodegenerate.it/api/v1/qrcode/generate-static";

        // Costruisci l'URL con i parametri
        var uriBuilder = new UriBuilder(endpoint);
        var query = HttpUtility.ParseQueryString(uriBuilder.Query);
        query["content"] = "https://www.tuosito.it";
        query["format"] = "svg";
        query["size"] = "300";
        uriBuilder.Query = query.ToString();

        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("x-api-key", apiKey);

            try
            {
                var response = await client.GetAsync(uriBuilder.Uri);
                response.EnsureSuccessStatusCode(); // Solleva un'eccezione in caso di errore HTTP

                // Leggi il contenuto della risposta (testo SVG)
                var svgContent = await response.Content.ReadAsStringAsync();

                // Salva il contenuto in un file
                await File.WriteAllTextAsync("qrcode.svg", svgContent);
                Console.WriteLine("QR Code generato e salvato come 'qrcode.svg'.");
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine($"Errore nella richiesta: {e.Message}");
            }
        }
    }
}

Esempi di Codice in Java

open

Per gli esempi in questo linguaggio, utilizzeremo la classe HttpClient, disponibile nativamente in Java 11 e versioni successive. HttpClient offre un'API moderna, asincrona e fluida per le richieste HTTP, rendendola la soluzione standard e preferita.

Richiesta POST

La richiesta POST è il metodo raccomandato per utilizzare la tua API, in quanto consente di inviare dati complessi (come oggetti JSON) nel corpo della richiesta, garantendo la piena funzionalità dell'API, inclusa la personalizzazione dei colori e l'aggiunta di un logo.

Indice

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class QrCodeGenerator {

    public static void main(String[] args) throws Exception {
        String apiKey = "la_tua_api_key";
        String endpoint = "https://qrcodegenerate.it/api/v1/qrcode/generate-static";

        // Costruisci il corpo JSON
        String jsonBody = "{"
            + "\"content\": \"https://www.tuosito.it\","
            + "\"format\": \"png\","
            + "\"size\": 200,"
            + "\"color\": { \"dark\": \"#000000\", \"light\": \"#FFFFFF\" },"
            + "\"logoUrl\": \"https://il-tuo-dominio.com/logo.png\""
            + "}";

        // Crea la richiesta HTTP
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(endpoint))
                .header("Content-Type", "application/json")
                .header("x-api-key", apiKey)
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        try {
            // Invia la richiesta e ottieni la risposta
            HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());

            // Verifica lo status code
            if (response.statusCode() == 200) {
                // Salva i byte dell'immagine in un file
                Path outputPath = Paths.get("qrcode.png");
                Files.write(outputPath, response.body());
                System.out.println("QR Code generato e salvato come 'qrcode.png'.");
            } else {
                System.out.println("Errore HTTP! Status: " + response.statusCode());
                System.out.println("Messaggio di errore: " + new String(response.body()));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Richiesta GET

La richiesta GET è più semplice e adatta per i casi d'uso dove tutti i parametri possono essere inclusi nell'URL come query string. Questo metodo non supporta parametri di tipo oggetto come color.

Indice

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class QrCodeGeneratorGet {

    public static void main(String[] args) throws Exception {
        String apiKey = "la_tua_api_key";
        String content = "https://www.tuosito.it";
        String format = "svg";
        int size = 300;

        // Costruisci l'URL finale con i parametri
        String finalUrl = String.format("https://qrcodegenerate.it/api/v1/qrcode/generate-static?content=%s&format=%s&size=%d",
                                        content, format, size);

        // Crea la richiesta HTTP
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(finalUrl))
                .header("x-api-key", apiKey)
                .GET()
                .build();

        try {
            // Invia la richiesta
            HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());

            // Verifica lo status code
            if (response.statusCode() == 200) {
                // Se il formato è SVG, salva il testo
                Path outputPath = Paths.get("qrcode.svg");
                Files.write(outputPath, response.body().getBytes());
                System.out.println("QR Code generato e salvato come 'qrcode.svg'.");
            } else {
                System.out.println("Errore HTTP! Status: " + response.statusCode());
                System.out.println("Messaggio di errore: " + response.body());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Esempi Asp Vb.Net

open

Useremo la classe HttpClient che è il metodo standard e moderno in .NET per le chiamate web.
In ASP.NET, dovresti includere la libreria System.Net.Http e, per la serializzazione JSON, System.Text.Json (o una libreria simile come Newtonsoft.Json).

Richiesta POST

Per la richiesta POST, devi creare un oggetto VB.NET che rappresenti i dati da inviare, serializzarlo in formato JSON e inviarlo nel corpo della richiesta.

Indice
            
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Text
Imports System.Text.Json

' Definisci la classe per i dati da inviare, come l'oggetto in JavaScript
Public Class QRCodeData
    Public Property content As String
    Public Property format As String
    Public Property size As Integer
    Public Property color As QRCodeColor
    Public Property logoUrl As String
End Class

Public Class QRCodeColor
    Public Property dark As String
    Public Property Propertylight As String
End Class

' Il metodo asincrono per l'invio della richiesta
Async Function GenerateQRCodePost() As Task
    Const apiKey As String = "la_tua_api_key"
    Const endpoint As String = "https://qrcodegenerate.it/api/v1/qrcode/generate-static"

    Dim data As New QRCodeData With {
        .content = "https://www.tuosito.it",
        .format = "png",
        .size = 200,
        .color = New QRCodeColor With {.dark = "#000000", .Propertylight = "#FFFFFF"},
        .logoUrl = "https://il-tuo-dominio.com/logo.png"
    }

    Using client As New HttpClient()
        client.DefaultRequestHeaders.Add("x-api-key", apiKey)
        Dim jsonContent As String = JsonSerializer.Serialize(data)
        Dim httpContent As New StringContent(jsonContent, Encoding.UTF8, "application/json")

        Try
            Dim response As HttpResponseMessage = Await client.PostAsync(endpoint, httpContent)
            
            response.EnsureSuccessStatusCode() ' Genera un'eccezione se lo stato non è 2xx

            Dim imageBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
            ' Ora puoi usare l'array di byte per salvare l'immagine o mostrarla
            Console.WriteLine("Immagine ricevuta con successo, dimensione: " & imageBytes.Length.ToString() & " byte.")

        Catch ex As HttpRequestException
            Console.WriteLine("Si è verificato un errore HTTP: " & ex.Message)
            Dim responseContent As String = ""
            Try
                ' Tenta di leggere il contenuto della risposta in caso di errore
                responseContent = Await ex.GetBaseException().Message.ToString() ' .Content.ReadAsStringAsync()
            Catch
                ' Fa nulla se non si riesce a leggere il contenuto
            End Try
            Console.WriteLine("Dettagli errore: " & responseContent)

        Catch ex As Exception
            Console.WriteLine("Si è verificato un errore generico: " & ex.Message)
        End Try
    End Using
End Function

Richiesta GET

Per la richiesta GET, i parametri sono aggiunti direttamente all'URL come "query string".

Indice
            
Imports System.Net.Http
Imports System.Net.Http.Headers

' Il metodo asincrono per l'invio della richiesta
Async Function GenerateQRCodeGet() As Task
    Const apiKey As String = "la_tua_api_key"
    Const endpointBase As String = "https://www.qrcodegenerate.it/api/v1/qrcode/generate-static"
    
    Dim content As String = "https://www.tuosito.it"
    Dim format As String = "svg"
    Dim size As Integer = 300

    ' Costruisci l'URL con i parametri
    Dim finalUrl As String = $"{endpointBase}?content={Uri.EscapeDataString(content)}&format={Uri.EscapeDataString(format)}&size={size}"

    Using client As New HttpClient()
        client.DefaultRequestHeaders.Add("x-api-key", apiKey)

        Try
            Dim response As HttpResponseMessage = Await client.GetAsync(finalUrl)

            response.EnsureSuccessStatusCode() ' Genera un'eccezione se lo stato non è 2xx

            Dim svgText As String = Await response.Content.ReadAsStringAsync()
            Console.WriteLine("Codice SVG ricevuto: " & svgText)
            
        Catch ex As HttpRequestException
            Console.WriteLine("Si è verificato un errore HTTP: " & ex.Message)

        Catch ex As Exception
            Console.WriteLine("Si è verificato un errore generico: " & ex.Message)
        End Try
    End Using
End Function

Esempio di Codice HTML/JavaScript (Client-Side)

open

Questo esempio mostra come è possibile utilizzare la nostra API direttamente dal browser di un utente, rendendola ideale per integrazioni veloci in pagine web o applicazioni front-end. L'esempio utilizza il metodo GET e fetch per la richiesta API.

Indice

<!DOCTYPE html>
<html lang="it">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Esempio API QR Code (GET)</title>
    <style>
        body { font-family: Arial, sans-serif; padding: 20px; background-color: #f4f4f4; }
        .container { max-width: 600px; margin: 0 auto; background-color: #fff; padding: 20px; border-radius: 8px; box-shadow: 0 0 10px rgba(0, 0, 0, 0.1); }
        input, button { width: 100%; padding: 10px; margin-bottom: 10px; border: 1px solid #ddd; border-radius: 4px; }
        button { background-color: #007bff; color: white; border: none; cursor: pointer; }
        button:hover { background-color: #0056b3; }
        #qrcode-container { margin-top: 20px; text-align: center; }
        #error-message { color: red; }
    </style>
</head>
<body>

<div class="container">
    <h2>Genera QR Code (Metodo GET)</h2>
    <p>Inserisci il testo o l'URL e genera un QR Code statico.</p>
    
    <form id="qrForm">
        <input type="text" id="content" placeholder="Inserisci il testo o l'URL" required>
        <button type="submit">Genera QR Code</button>
    </form>
    
    <div id="qrcode-container">
        <p>Il tuo QR Code apparirà qui.</p>
        <img id="qrcode-image" src="" alt="QR Code generato" style="display:none; max-width: 100%;">
        <p id="error-message"></p>
    </div>
</div>

<script>
document.getElementById('qrForm').addEventListener('submit', async (e) => {
    e.preventDefault(); // Impedisce l'invio del form

    const apiKey = 'la_tua_api_key'; // Sostituisci con la tua chiave API
    const endpointBase = 'https://qrcodegenerate.it/api/v1/qrcode/generate-static';
    
    const content = document.getElementById('content').value;
    const qrcodeImage = document.getElementById('qrcode-image');
    const errorMessage = document.getElementById('error-message');

    // Resetta i messaggi e l'immagine
    errorMessage.textContent = '';
    qrcodeImage.style.display = 'none';

    if (!content) {
        errorMessage.textContent = 'Inserisci un testo o un URL.';
        return;
    }

    try {
        const params = new URLSearchParams({
            content: content,
            format: 'png', // Puoi aggiungere altri parametri qui
            size: 300
        });

        const finalUrl = `${endpointBase}?${params.toString()}`;

        const response = await fetch(finalUrl, {
            method: 'GET',
            headers: {
                'x-api-key': apiKey
            }
        });

        if (!response.ok) {
            const errorText = await response.text();
            throw new Error(`Errore HTTP! Status: ${response.status}, Messaggio: ${errorText}`);
        }

        // Se la risposta è ok, gestisci il BLOB dell'immagine
        const imageBlob = await response.blob();
        const imageUrl = URL.createObjectURL(imageBlob);

        // Visualizza l'immagine
        qrcodeImage.src = imageUrl;
        qrcodeImage.style.display = 'block';

    } catch (error) {
        console.error('Si è verificato un errore:', error);
        errorMessage.textContent = `Errore nella generazione: ${error.message}`;
    }
});
</script>

</body>
</html>

Risposte API

La nostra API risponde con specifici status code HTTP per indicare il risultato di ogni richiesta. In caso di errore, il corpo della risposta conterrà un oggetto JSON che fornisce un messaggio chiaro e una descrizione del problema.

Risposte di Successo 🎉

In caso di successo, la richiesta avrà uno status code 200 OK. Il corpo della risposta sarà un'immagine (formati png, jpeg, webp, svg) o una stringa di testo (base64url).

200 OK Successo

La richiesta è stata elaborata con successo.

Corpo della Risposta:

Il corpo della risposta conterrà direttamente il QR code generato in formato immagine (e.g., image/png) o come stringa di testo (base64url).

Risposte di Errore 🚨

Quando si verifica un problema, la risposta avrà uno status code di errore e un corpo JSON dettagliato.

400 Bad Request Errore Cliente

I parametri di richiesta sono mancanti o non validi.

Corpo della Risposta:

{
"status": 400,
"message": "Parametri di richiesta mancanti o non validi."
}

401 Unauthorized Errore Cliente

La chiave API fornita è mancante o non valida.

Corpo della Risposta:

{
"status": 401,
"message": "Chiave API mancante o non valida."
}

403 Forbidden Errore Cliente

Il limite di richieste giornaliere per questa API Key è stato superato.

Corpo della Risposta:

{
"status": 403,
"message": "Limite di richieste giornaliere superato."
}

429 Too Many Requests Errore Cliente

Il limite di richieste per minuto (rate limiting) è stato superato.

Corpo della Risposta:

{
"status": 429,
"message": "Limite di richieste per minuto superato."
}

500 Internal Server Error Errore Server

Il server ha riscontrato un problema inaspettato.

Corpo della Risposta:

{
"status": 500,
"message": "Si è verificato un errore interno."
}

Introduzione

Indice Documentazione API-Rest

Esempi di integrazione:

Genera un QR Code Statico (Testo o URL)

Richiesta:

Parametri del Body (JSON) / URL

Esempi di Codice in Node.js

Esempio con Richiesta POST:

Esempio con Richiesta GET

Esempi di Codice in Python

Esempio con Richiesta POST

Esempio con Richiesta GET

Esempi di Codice in PHP

Esempio con Richiesta POST

Esempio con Richiesta GET

Esempi di Codice in Ruby

Esempio con Richiesta POST

Esempio con Richiesta GET

Esempi di Codice in TypeScript

Esempio con Richiesta POST

Esempio con Richiesta GET

Esempi di Codice in Swift

Richiesta POST

Richiesta GET

Esempi di Codice in Go (Golang)

Richiesta POST

Richiesta GET

Esempi C++ con libcurl

Richiesta POST

Esempio con Richiesta GET

Esempi di Codice in C#

Richiesta POST

Richiesta GET

Esempi di Codice in Java

Richiesta POST

Richiesta GET

Esempi Asp Vb.Net

Richiesta POST

Richiesta GET

Esempio di Codice HTML/JavaScript (Client-Side)

Risposte API

Risposte di Successo 🎉

Risposte di Errore 🚨