How do I get a UUID API key?

Sign up at api.toolsmatic.me/signup to receive your free API key. Free tier includes 10,000 requests/month.

What UUID versions are supported?

All RFC 4122 versions are supported: v1 (timestamp+MAC), v3 (MD5 hash), v4 (random), v5 (SHA-1 hash), v6 (reordered timestamp), v7 (Unix timestamp), v8 (custom).

What are the rate limits?

Free tier: 100 requests/minute. Pro: 1,000 requests/minute. Enterprise: Unlimited with custom SLA.

Can I generate UUIDs in bulk?

Yes, use POST /uuid/bulk endpoint to generate up to 1,000,000 UUIDs in a single request. Results returned as JSON array.

UUID Generator REST API Documentation — Complete API Reference

🚀 Quick Start

Base URL: https://api.toolsmatic.me/v1

Authentication: API key required (included in headers)

curl -X POST https://api.toolsmatic.me/v1/uuid/generate \\
  -H "X-API-Key: your_api_key_here" \\
  -H "Content-Type: application/json" \\
  -d '{"version": "v4", "count": 1}'

Response:

{
  "success": true,
  "uuids": ["f47ac10b-58cc-4372-a567-0e02b2c3d479"],
  "version": "v4",
  "count": 1,
  "timestamp": "2025-01-15T10:30:00Z"
}

🔐 Authentication

All API requests require an API key passed in the X-API-Key header.

📘 Getting an API Key:
Sign up at toolsmatic.me/api/signup to get your free API key. Free tier includes 10,000 requests/month.

Rate Limits

Plan	Requests/Month	Requests/Minute	Bulk Limit
Free	10,000	100	1,000 UUIDs
Pro	1,000,000	1,000	100,000 UUIDs
Enterprise	Unlimited	10,000	10,000,000 UUIDs

📡 API Endpoints

POST /uuid/generate

Generate one or more UUIDs with specified version and format.

Request Body

Parameter	Type	Required	Description
`version`	string	optional	UUID version: v1, v3, v4 (default), v5, v6, v7, v8
`count`	integer	optional	Number of UUIDs to generate (1-10,000,000). Default: 1
`format`	string	optional	Output format: standard, hex, base64, urn, binary. Default: standard
`namespace`	string	optional	Required for v3/v5: dns, url, oid, x500, or custom UUID
`name`	string	optional	Required for v3/v5: name/data to hash

Example Requests

# Generate single UUID v4
curl -X POST https://api.toolsmatic.me/v1/uuid/generate \\
  -H "X-API-Key: your_api_key" \\
  -H "Content-Type: application/json" \\
  -d '{"version": "v4", "count": 1}'

# Bulk generate 1000 UUID v7
curl -X POST https://api.toolsmatic.me/v1/uuid/generate \\
  -H "X-API-Key: your_api_key" \\
  -H "Content-Type: application/json" \\
  -d '{"version": "v7", "count": 1000, "format": "hex"}'

// Using fetch API
const response = await fetch('https://api.toolsmatic.me/v1/uuid/generate', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    version: 'v4',
    count: 100
  })
});

const data = await response.json();
console.log(data.uuids);

import requests

response = requests.post(
    'https://api.toolsmatic.me/v1/uuid/generate',
    headers={
        'X-API-Key': 'your_api_key',
        'Content-Type': 'application/json'
    },
    json={
        'version': 'v7',
        'count': 500
    }
)

data = response.json()
print(data['uuids'])

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func generateUUIDs() {
    payload := map[string]interface{}{
        "version": "v4",
        "count": 1000,
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", 
        "https://api.toolsmatic.me/v1/uuid/generate", 
        bytes.NewBuffer(jsonData))
    
    req.Header.Set("X-API-Key", "your_api_key")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, _ := client.Do(req)
}

Response

{
  "success": true,
  "uuids": [
    "f47ac10b-58cc-4372-a567-0e02b2c3d479",
    "a3b12f90-1234-4abc-8def-0123456789ab"
  ],
  "version": "v4",
  "count": 2,
  "format": "standard",
  "timestamp": "2025-01-15T10:30:00Z",
  "requestId": "req_abc123"
}

POST /uuid/validate

Validate UUID format and extract version/variant information.

Request Body

Parameter	Type	Required	Description
`uuid`	string	required	UUID string to validate
`strict`	boolean	optional	Strict RFC 4122 validation. Default: true

Example

curl -X POST https://api.toolsmatic.me/v1/uuid/validate \\
  -H "X-API-Key: your_api_key" \\
  -H "Content-Type: application/json" \\
  -d '{"uuid": "f47ac10b-58cc-4372-a567-0e02b2c3d479"}'

Response

{
  "valid": true,
  "uuid": "f47ac10b-58cc-4372-a567-0e02b2c3d479",
  "version": "v4",
  "variant": "RFC 4122",
  "timeBased": false,
  "format": "standard"
}

POST /uuid/parse

Parse UUID and extract all fields including timestamps for v1/v6/v7.

Example Request

curl -X POST https://api.toolsmatic.me/v1/uuid/parse \\
  -H "X-API-Key: your_api_key" \\
  -H "Content-Type: application/json" \\
  -d '{"uuid": "6ba7b810-9dad-11d1-80b4-00c04fd430c8"}'

Response

{
  "valid": true,
  "version": "v1",
  "variant": "RFC 4122",
  "timeBased": true,
  "timestamp": "1997-02-03T15:52:14.000Z",
  "fields": {
    "timeLow": "6ba7b810",
    "timeMid": "9dad",
    "timeHiVersion": "11d1",
    "clockSeq": "80b4",
    "node": "00c04fd430c8"
  }
}

POST /uuid/bulk

High-performance bulk UUID generation with export formats (JSON, CSV, SQL, YAML).

Request Body

Parameter	Type	Required	Description
`count`	integer	required	Number of UUIDs (1 to 10,000,000)
`version`	string	optional	UUID version (default: v4)
`exportFormat`	string	optional	json (default), csv, sql, yaml, plain
`compression`	string	optional	gzip, none (default)

Example

curl -X POST https://api.toolsmatic.me/v1/uuid/bulk \\
  -H "X-API-Key: your_api_key" \\
  -H "Content-Type: application/json" \\
  -d '{"count": 100000, "version": "v7", "exportFormat": "csv"}' \\
  -o uuids.csv

🔔 Webhooks

Receive real-time notifications for UUID generation events.

Setup Webhook

Configure webhook endpoints in your dashboard at toolsmatic.me/api/webhooks

Webhook Payload Example

{
  "event": "uuid.generated",
  "timestamp": "2025-01-15T10:30:00Z",
  "data": {
    "count": 1000,
    "version": "v7",
    "requestId": "req_abc123",
    "userId": "user_123"
  }
}

Supported Events

uuid.generated — UUID successfully generated
uuid.validated — UUID validation completed
uuid.parsed — UUID parsing completed
bulk.completed — Bulk generation finished

⚠️ Error Codes

Code	Message	Solution
`400`	Invalid request parameters	Check request body format and required fields
`401`	Unauthorized - Invalid API key	Verify X-API-Key header is correct
`429`	Rate limit exceeded	Wait or upgrade to higher tier
`500`	Internal server error	Contact support@toolsmatic.me

📚 Official SDKs

Use our official client libraries for faster integration

JavaScript/TypeScript
npm install @toolsmatic/uuid

Python
pip install toolsmatic-uuid

Go
go get github.com/toolsmatic/uuid-go

Ruby
gem install toolsmatic-uuid

UUID API Comparison for Architecture Planning

Approach	Advantages	Tradeoffs	Best Fit
Dedicated UUID API	Centralized governance, version flexibility, audit-ready workflows	External dependency and network latency considerations	Distributed systems, multi-team platforms, compliance-heavy environments
Language-Native UUID Libraries	Low-latency local generation with no remote dependency	Inconsistent behavior across services and weaker centralized observability	Single-service apps and internal tools with simple needs
Hybrid API + Local Fallback	Resilience during outages, continuity for mission-critical flows	Higher implementation complexity and synchronization requirements	Enterprise apps with strict uptime and governance requirements

Frequently Asked Questions

When should I use UUID v4 vs UUID v7?

Use UUID v4 for purely random identifiers and broad compatibility. Use UUID v7 when you need time-ordered IDs that improve indexing and sorting performance in many storage systems.

Is UUID API generation safe for high-throughput systems?

Yes, provided your architecture includes retry strategy, rate-limit awareness, and workload-appropriate plan tiers. For ultra-low-latency paths, consider hybrid fallback patterns.

Can I validate and parse third-party UUIDs with this API?

Yes. Validation and parsing endpoints are designed for both internally generated IDs and incoming UUIDs from external systems, with support for metadata extraction where applicable.

How do I make UUID usage auditable for enterprise compliance?

Capture request IDs, timestamps, version usage, and endpoint outcomes in logs. Pair that with key rotation and access controls for API credentials to maintain traceability.