ForHosting KIT · Developer Utilities

Generate a UUID

Picking an identifier scheme matters more than it seems, once a table has millions of rows the wrong choice hurts index performance for years. This uuid generator api produces v4, v7 and ULID identifiers on demand, in whatever volume a migration or a new schema requires, without you writing the generation logic yourself.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Not all unique identifiers behave the same

A v4 UUID is 122 bits of randomness, which makes it unguessable but also unsortable and, at high insert volumes, unfriendly to database indexes that expect roughly ordered keys. A v7 UUID fixes exactly that by embedding a millisecond timestamp in the leading bits, so records inserted close together in time sort close together on disk, while still carrying enough randomness to avoid collisions. ULID solves the same ordering problem with a different encoding, using Crockford's base32 for a shorter, URL-safe, case-insensitive string.

What POST /dev/uuid does

You specify the version, v4, v7 or ULID, and a count, and the task returns that many identifiers generated with a cryptographically sound source of randomness. There's no artificial ceiling forcing you to make dozens of small requests when a single migration needs identifiers for an entire table; you ask for the batch you need and get it back as one result.

A short, useful history

UUIDs were standardized in the 1980s as part of the Apollo Network Computing System, later formalized in RFC 4122. For over two decades v4, purely random, was the default choice, because it required no coordination between systems generating IDs independently. v7 is recent, ratified in 2024 specifically to address the index-locality problem that random UUIDs cause in modern high-throughput databases, and ULID emerged from the same community pressure a few years earlier as a pragmatic, non-standardized alternative.

Where this fits into real systems

Database migrations that need to backfill primary keys, distributed systems generating IDs across services without a central counter, and event logs that benefit from roughly time-ordered identifiers are the three situations this shows up in most. Because the task runs asynchronously, a request for a large batch doesn't block your deployment pipeline; you queue it, keep working, and pull the result from a signed webhook or a signed link valid for 24 hours.

Choosing between the three

If unpredictability matters more than sort order, v4 remains the right default. If you're inserting rows at volume and care about index performance, v7 is purpose-built for that. If you want a shorter, human-typeable string with the same time-ordering benefit, ULID is the practical choice. None of the three is universally 'better,' they solve different constraints.

What you can do with it

Bulk primary key backfill

Generate a large batch of v7 UUIDs at once to backfill primary keys during a database migration without writing custom generation code.

Distributed ID generation

Produce v4 UUIDs for services that create records independently across regions, with no coordination needed to avoid collisions.

Sortable event log identifiers

Use ULID for log entries or queue messages that benefit from roughly chronological ordering combined with a short, readable string.

Test data seeding

Generate thousands of unique identifiers in one call to seed a staging database without scripting a local generator.

FAQ

What identifier types does this uuid generator api support?

UUID v4, UUID v7 and ULID, selectable per request depending on whether you need randomness, time-ordering, or a shorter encoded string.

Can I generate UUIDs in bulk in a single call?

Yes, you specify a count along with the version and receive the full batch back in one result, no need to loop over single-ID requests.

What's the difference between UUID v4 and v7?

v4 is fully random and unsortable; v7 embeds a millisecond timestamp so identifiers generated close in time sort close together, which helps database index performance.

Is ULID the same as a UUID?

No, ULID is a related but distinct format, it uses Crockford's base32 encoding and is designed to be shorter and URL-safe while still time-ordered.

Is there a free tier?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

How much does it cost?

$0.002 per request, charged only for successfully completed tasks.

How do I retrieve generated identifiers?

POST /dev/uuid returns a task_id immediately, and the generated list arrives via signed webhook or a signed link valid for 24 hours.

What happens if generation fails?

The task retries automatically up to three times; if it still fails you get a clear error and are not charged.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/dev/uuid

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/dev/uuid \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"input":"…"}'

const res = await fetch("https://api.kit.forhosting.com/dev/uuid", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "input": "…"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/uuid",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "input": "…"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/uuid", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"input":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"input":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/uuid", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "input": "…"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.uuid",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Read the full KIT documentation →

Run — free