QuantumLiFi API Documentation

import requests

# Using the requests library
def get_random_int(min_value=1, max_value=100):
    api_key = 'your-api-key-here'
    url = f'https://quantumlifi.com/api/random/int?min={min_value}&max={max_value}'

    headers = {
        'X-API-Key': api_key
    }

    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()  # Raises an exception for 4XX/5XX responses

        data = response.json()
        print(f"Random number: {data['value']}")
        print(f"Source: {data['source']}")
        return data
    except requests.exceptions.RequestException as e:
        print(f"Error fetching random number: {e}")
        raise

# Using the official client library
from quantumlifi import QuantumClient

client = QuantumClient(api_key='your-api-key-here')

def get_random_bytes(length=32, format='hex'):
    try:
        response = client.get_random_bytes(length=length, format=format)
        print(f"Random bytes: {response['data']}")
        print(f"Source: {response['source']}")
        return response
    except Exception as e:
        print(f"Error: {e}")
        raise
                  

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

type RandomIntResponse struct {
    Success   bool   `json:"success"`
    Source    string `json:"source"`
    Value     int    `json:"value"`
    Timestamp string `json:"timestamp"`
}

func GetRandomInt(min, max int) (RandomIntResponse, error) {
    apiKey := "your-api-key-here"
    url := fmt.Sprintf("https://quantumlifi.com/api/random/int?min=%d&max=%d", min, max)

    client := &http.Client{
        Timeout: time.Second * 10,
    }

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return RandomIntResponse{}, err
    }

    req.Header.Set("X-API-Key", apiKey)

    resp, err := client.Do(req)
    if err != nil {
        return RandomIntResponse{}, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return RandomIntResponse{}, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
    }

    bodyBytes, err := io.ReadAll(resp.Body)
    if err != nil {
        return RandomIntResponse{}, err
    }

    var result RandomIntResponse
    if err := json.Unmarshal(bodyBytes, &result); err != nil {
        return RandomIntResponse{}, err
    }

    fmt.Printf("Random number: %d\n", result.Value)
    fmt.Printf("Source: %s\n", result.Source)

    return result, nil
}

// Using the official client library
// import "github.com/quantumlifi/go-client"
                  

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import org.json.JSONObject;

public class QuantumLiFiExample {
    private static final String API_KEY = "your-api-key-here";
    private static final String BASE_URL = "https://quantumlifi.com/api";

    private final HttpClient httpClient;

    public QuantumLiFiExample() {
        this.httpClient = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(10))
                .build();
    }

    public JSONObject getRandomInt(int min, int max) throws Exception {
        String url = String.format("%s/random/int?min=%d&max=%d", BASE_URL, min, max);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("X-API-Key", API_KEY)
                .GET()
                .build();

        HttpResponse response = httpClient.send(request,
                HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() != 200) {
            throw new RuntimeException("Unexpected status code: " + response.statusCode());
        }

        JSONObject result = new JSONObject(response.body());

        System.out.println("Random number: " + result.getInt("value"));
        System.out.println("Source: " + result.getString("source"));

        return result;
    }

    public static void main(String[] args) {
        try {
            QuantumLiFiExample example = new QuantumLiFiExample();
            JSONObject result = example.getRandomInt(1, 100);
            System.out.println(result.toString(2));  // Pretty print JSON
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// Using the official client library
// import com.quantumlifi.api.QuantumClient;