UUID Generator API Examples

Code examples for generating UUIDs using the Sinaty API in various programming languages.

JavaScript/Node.js

Basic UUID Generation

// Generate a single UUID
async function generateUUID() {
    try {
        const response = await fetch('https://api.sinaty.business/uuid/');
        const data = await response.json();
        return data.uuids[0];
    } catch (error) {
        console.error('Error generating UUID:', error);
    }
}

// Generate multiple UUIDs
async function generateMultipleUUIDs(count = 5) {
    try {
        const response = await fetch(`https://api.sinaty.business/uuid/?count=${count}`);
        const data = await response.json();
        return data.uuids;
    } catch (error) {
        console.error('Error generating UUIDs:', error);
    }
}

// Generate secure UUIDs in compact format
async function generateSecureUUIDs(count = 3) {
    try {
        const response = await fetch(
            `https://api.sinaty.business/uuid/?count=${count}&format=compact&secure=true`
        );
        const data = await response.json();
        return data.uuids;
    } catch (error) {
        console.error('Error generating secure UUIDs:', error);
    }
}

Using Axios

const axios = require('axios');

async function generateUUIDs() {
    try {
        const response = await axios.get('https://api.sinaty.business/uuid/', {
            params: {
                count: 10,
                format: 'standard',
                secure: true,
                uppercase: false
            }
        });
        
        console.log('Generated UUIDs:', response.data.uuids);
        return response.data;
    } catch (error) {
        console.error('Error:', error.response?.data || error.message);
    }
}

Python

Using requests

import requests

def generate_uuid(count=1, format='standard', secure=False):
    """Generate UUIDs using the Sinaty API"""
    url = 'https://api.sinaty.business/uuid/'
    params = {
        'count': count,
        'format': format,
        'secure': secure
    }
    
    try:
        response = requests.get(url, params=params)
        response.raise_for_status()
        data = response.json()
        return data['uuids']
    except requests.exceptions.RequestException as e:
        print(f"Error generating UUID: {e}")
        return None

# Examples
single_uuid = generate_uuid()
multiple_uuids = generate_uuid(count=5, format='compact')
secure_uuids = generate_uuid(count=3, format='standard', secure=True)

Using aiohttp (Async)

import aiohttp
import asyncio

async def generate_uuid_async(count=1, format='standard', secure=False):
    """Generate UUIDs asynchronously"""
    url = 'https://api.sinaty.business/uuid/'
    params = {
        'count': count,
        'format': format,
        'secure': secure
    }
    
    async with aiohttp.ClientSession() as session:
        async with session.get(url, params=params) as response:
            if response.status == 200:
                data = await response.json()
                return data['uuids']
            else:
                print(f"Error: {response.status}")
                return None

# Usage
async def main():
    uuids = await generate_uuid_async(count=10, format='compact')
    print(f"Generated UUIDs: {uuids}")

# Run the async function
asyncio.run(main())

PHP

Using cURL

<?php

function generateUUID($count = 1, $format = 'standard', $secure = false) {
    $url = 'https://api.sinaty.business/uuid/';
    $params = http_build_query([
        'count' => $count,
        'format' => $format,
        'secure' => $secure ? 'true' : 'false'
    ]);
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url . '?' . $params);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        $data = json_decode($response, true);
        return $data['uuids'];
    } else {
        echo "Error: HTTP $httpCode\n";
        return null;
    }
}

// Examples
$single_uuid = generateUUID();
$multiple_uuids = generateUUID(5, 'compact');
$secure_uuids = generateUUID(3, 'standard', true);

Using Guzzle

<?php

use GuzzleHttp\Client;

function generateUUIDWithGuzzle($count = 1, $format = 'standard', $secure = false) {
    $client = new Client();
    
    try {
        $response = $client->get('https://api.sinaty.business/uuid/', [
            'query' => [
                'count' => $count,
                'format' => $format,
                'secure' => $secure
            ]
        ]);
        
        $data = json_decode($response->getBody(), true);
        return $data['uuids'];
    } catch (Exception $e) {
        echo "Error: " . $e->getMessage() . "\n";
        return null;
    }
}

Go

package main

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

type UUIDResponse struct {
    UUIDs     []string `json:"uuids"`
    Count     int      `json:"count"`
    Format    string   `json:"format"`
    Secure    bool     `json:"secure"`
    Timestamp string   `json:"timestamp"`
}

func generateUUID(count int, format string, secure bool) (*UUIDResponse, error) {
    baseURL := "https://api.sinaty.business/uuid/"
    
    // Build query parameters
    params := url.Values{}
    params.Add("count", fmt.Sprintf("%d", count))
    params.Add("format", format)
    params.Add("secure", fmt.Sprintf("%t", secure))
    
    // Make request
    resp, err := http.Get(baseURL + "?" + params.Encode())
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    // Read response
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    
    // Parse JSON
    var result UUIDResponse
    err = json.Unmarshal(body, &result)
    if err != nil {
        return nil, err
    }
    
    return &result, nil
}

func main() {
    // Generate single UUID
    result, err := generateUUID(1, "standard", false)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    
    fmt.Printf("Generated UUIDs: %v\n", result.UUIDs)
}

Ruby

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

def generate_uuid(count = 1, format = 'standard', secure = false)
  url = URI('https://api.sinaty.business/uuid/')
  url.query = URI.encode_www_form({
    count: count,
    format: format,
    secure: secure
  })
  
  begin
    response = Net::HTTP.get_response(url)
    if response.is_a?(Net::HTTPSuccess)
      data = JSON.parse(response.body)
      return data['uuids']
    else
      puts "Error: HTTP #{response.code}"
      return nil
    end
  rescue => e
    puts "Error: #{e.message}"
    return nil
  end
end

# Examples
single_uuid = generate_uuid
multiple_uuids = generate_uuid(5, 'compact')
secure_uuids = generate_uuid(3, 'standard', true)

cURL Examples

Basic Usage

# Generate a single UUID
curl "https://api.sinaty.business/uuid/"

# Generate 5 UUIDs in compact format
curl "https://api.sinaty.business/uuid/?count=5&format=compact"

# Generate secure UUIDs
curl "https://api.sinaty.business/uuid/?count=3&secure=true"

# Generate uppercase UUIDs
curl "https://api.sinaty.business/uuid/?count=2&uppercase=true"

Advanced Usage

# Generate URN format UUIDs
curl "https://api.sinaty.business/uuid/?count=3&format=urn"

# Generate Base64 encoded UUIDs
curl "https://api.sinaty.business/uuid/?count=2&format=base64"

# Generate braced UUIDs with secure random
curl "https://api.sinaty.business/uuid/?count=4&format=braced&secure=true"

# POST request with JSON body
curl -X POST "https://api.sinaty.business/uuid/" \
  -H "Content-Type: application/json" \
  -d '{"count": 10, "format": "compact", "secure": true}'

Error Handling Examples

JavaScript

async function generateUUIDWithErrorHandling() {
    try {
        const response = await fetch('https://api.sinaty.business/uuid/?count=1001');
        
        if (!response.ok) {
            const errorData = await response.json();
            console.error('API Error:', errorData.error);
            console.error('Details:', errorData.details);
            return null;
        }
        
        const data = await response.json();
        return data.uuids;
    } catch (error) {
        console.error('Network Error:', error);
        return null;
    }
}

Python

def generate_uuid_with_error_handling(count=1, format='standard'):
    try:
        response = requests.get('https://api.sinaty.business/uuid/', params={
            'count': count,
            'format': format
        })
        
        if response.status_code == 200:
            data = response.json()
            return data['uuids']
        else:
            error_data = response.json()
            print(f"API Error: {error_data.get('error')}")
            print(f"Details: {error_data.get('details')}")
            return None
            
    except requests.exceptions.RequestException as e:
        print(f"Network Error: {e}")
        return None
    except json.JSONDecodeError as e:
        print(f"JSON Parse Error: {e}")
        return None

Integration Examples

React Component

import React, { useState, useEffect } from 'react';

function UUIDGenerator() {
    const [uuids, setUuids] = useState([]);
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState(null);

    const generateUUIDs = async (count = 5) => {
        setLoading(true);
        setError(null);
        
        try {
            const response = await fetch(
                `https://api.sinaty.business/uuid/?count=${count}&format=compact`
            );
            
            if (!response.ok) {
                const errorData = await response.json();
                throw new Error(errorData.error);
            }
            
            const data = await response.json();
            setUuids(data.uuids);
        } catch (err) {
            setError(err.message);
        } finally {
            setLoading(false);
        }
    };

    return (
        <div>
            <button onClick={() => generateUUIDs(5)} disabled={loading}>
                {loading ? 'Generating...' : 'Generate 5 UUIDs'}
            </button>
            
            {error && <div style={{color: 'red'}}>Error: {error}</div>}
            
            {uuids.length > 0 && (
                <div>
                    <h3>Generated UUIDs:</h3>
                    <ul>
                        {uuids.map((uuid, index) => (
                            <li key={index}>{uuid}</li>
                        ))}
                    </ul>
                </div>
            )}
        </div>
    );
}

export default UUIDGenerator;

Node.js Express Middleware

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

const app = express();

// Middleware to generate request ID
async function generateRequestId(req, res, next) {
    try {
        const response = await fetch('https://api.sinaty.business/uuid/?format=compact');
        const data = await response.json();
        req.requestId = data.uuids[0];
        next();
    } catch (error) {
        console.error('Error generating request ID:', error);
        req.requestId = 'fallback-id';
        next();
    }
}

app.use(generateRequestId);

app.get('/api/data', (req, res) => {
    res.json({
        requestId: req.requestId,
        data: 'Your data here'
    });
});

Ready to start generating UUIDs? Check out the API endpoints for complete parameter documentation.

IP Geolocation API

Password Generator API

UUID Generator API

Number Generator API

Hash Generator API

Text Utilities API

Time Utilities API

Examples

UUID Generator API Examples

JavaScript/Node.js

Basic UUID Generation

Using Axios

Python

Using requests

Using aiohttp (Async)

PHP

Using cURL

Using Guzzle

Go

Ruby

cURL Examples

Basic Usage

Advanced Usage

Error Handling Examples

JavaScript

Python

Integration Examples

React Component

Node.js Express Middleware

IP Geolocation API

Password Generator API

UUID Generator API

Number Generator API

Hash Generator API

Text Utilities API

Time Utilities API

​UUID Generator API Examples

​JavaScript/Node.js

​Basic UUID Generation

​Using Axios

​Python

​Using requests

​Using aiohttp (Async)

​PHP

​Using cURL

​Using Guzzle

​Go

​Ruby

​cURL Examples

​Basic Usage

​Advanced Usage

​Error Handling Examples

​JavaScript

​Python

​Integration Examples

​React Component

​Node.js Express Middleware

UUID Generator API Examples

JavaScript/Node.js

Basic UUID Generation

Using Axios

Python

Using requests

Using aiohttp (Async)

PHP

Using cURL

Using Guzzle

Go

Ruby

cURL Examples

Basic Usage

Advanced Usage

Error Handling Examples

JavaScript

Python

Integration Examples

React Component

Node.js Express Middleware