UUID Generator - Bulk UUID v4, UUID v7, ULID, NanoID and Short IDs

Generate up to 10,000 unique ids per batch, in the five formats modern systems actually use - UUID v4 (random), UUID v7 (time-sortable, the current default for database keys), ULID (Crockford base32, lexicographically sortable), NanoID (21-character URL-safe), and short (8-character base62). Ask for several kinds in one run; each comes back as its own batch. $0.0004 per batch, whatever its size.

Every id is generated with Node's cryptographic random source (crypto.randomUUID and crypto.randomBytes). No Math.random ids, ever.

What you get

Per requested id type, one batch record with these exact fields:

• ok - true when the batch generated
• type - v4, v7, ulid, nanoid or short
• count - how many ids are in this batch
• sortable - true for v7 and ulid (their timestamp prefixes order by creation time)
• uppercase - whether the uppercase option was applied
• generatedAt - ISO 8601 timestamp of generation
• ids - the array of ids
• error - present instead of ids when you asked for a type we do not generate. Never charged.

Example 1: a batch of time-sortable database keys

Input:

{ "type": "v7", "count": 3 }

Output (real run, 2026-08-15):

{
  "type": "v7",
  "ok": true,
  "count": 3,
  "uppercase": false,
  "sortable": true,
  "generatedAt": "2026-08-15T16:10:33.879Z",
  "ids": [
    "01a00630-7417-7e9c-9bc0-eb7f58745890",
    "01a00630-7417-7a61-b0d3-da9b72786170",
    "01a00630-7417-7a61-8966-6cc1472bee23"
  ]
}

Note the shared 01a00630-7417 prefix: that is the millisecond timestamp, which is what makes v7 sort by creation time and insert cleanly into a b-tree index.

Example 2: several formats in one run

Input:

{ "types": ["v7", "ulid", "nanoid"], "count": 3 }

Returns three batch records, one per type, each charged once. Real ids from that run (2026-08-15):

{ "type": "ulid",   "sortable": true,  "ids": ["01M0330X2CYE786KND5EK77PT7", "01M0330X2CE916HKEJ90HE55Y4", "01M0330X2C71A42GNNSYWBKEGM"] }
{ "type": "nanoid", "sortable": false, "ids": ["-Cr5izj5Jaj4EXELiLMeR", "uoipBpsYDknQl2mJhee-4", "zOvujSHTteNtQN7gclEoE"] }

The ULIDs share their leading timestamp characters the same way the v7s do.

When types is filled, the single type field is ignored - you get exactly the batches you listed, and are charged for exactly those.

Example 3: a type we do not generate

Input:

{ "type": "v5" }

Output:

{ "type": "v5", "ok": false, "error": "Unknown id type \"v5\". Valid: v4, v7, ulid, nanoid, short" }

It refuses rather than quietly handing back a v4. Asking for one thing and receiving another is the worst possible failure for an id generator, so it is never done, and the refusal is not charged.

Pricing

$0.0004 per batch generated. No start fee. One event covers one batch of one type, whether that batch holds 1 id or 10,000 - so 10,000 UUID v7s cost $0.0004 total. Asking for three types in one run is three batches and three charges. Unknown types are recorded and never charged.

Honest comparison, read from the Apify Store on 2026-08-07: rl1987/uuid-generator charges $0.01 per start, thescrapelab/guid-forge $0.0005 start plus a per-item fee. Per-item pricing on an id generator is the shape to watch - it is what turns a 10,000-id batch into real money.

Also honest: every language has a UUID library, and generating ids locally is free and instant. Pay for this when you need ids inside a no-code pipeline, as a step in an Apify workflow, or as a tool an AI agent can call - not because generating a UUID is hard.

When NOT to use this

• Namespace-deterministic ids (UUID v3 and v5). Those hash a namespace and a name so that the same input always produces the same id. This generator does not do that, and will not approximate it. If you need v5, use a library.
• UUID v1. MAC-address-based v1 is not generated here, deliberately - it embeds the host's hardware address.
• Ids that must be unguessable AND hide their creation time. v7 and ULID leak the millisecond they were made, by design. For public tokens use NanoID or v4.
• Session tokens, API keys, password reset links. Use your framework's token generator, which handles storage, expiry and comparison. These are ids, not credentials - the 8-character short type especially is for human-facing codes, not security.
• Strictly monotonic ids within a single millisecond. See the limits below.

Honest limits

• Types generated: v4, v7, ulid, nanoid, short. Not v1, v3 or v5.
• v7 and ULID sortability is millisecond-granular. Ids created within the same millisecond share a timestamp prefix, and their random tails are not monotonic within that millisecond (this matches the specification's basic mode). Across milliseconds, creation order sorts correctly.
• Up to 10,000 ids per batch; the ids are returned in your run's dataset.
• uppercase applies to the whole batch and will change NanoID and short ids semantically, since their alphabets are case-sensitive - two ids that differed only by case would collide after uppercasing. Use it for v4, v7 and ULID.

FAQ

What is UUID v7 and why would I use it instead of v4 for database keys? v7 puts a millisecond timestamp in its leading bits, so ids sort roughly by creation time. Inserts land at the end of the index instead of scattering through it, which means less b-tree fragmentation and faster inserts on large tables - and you get creation-time ordering for free. v4 is pure random and scatters.

When should I pick ULID over UUID v7? They sort the same way. ULID is 26 case-insensitive Crockford base32 characters with no dashes, which is friendlier in URLs, filenames and double-click selection. Pick v7 when you already have UUID-typed columns, ULID when the id is going to be seen and handled by people.

Are NanoIDs safe to use in public URLs? Yes. 21 characters over a 64-symbol alphabet is about 126 bits of randomness, generated with rejection sampling so the distribution is unbiased, from a cryptographic source. That is comparable to a UUID v4 for collision resistance in a shorter string.

How many ids can I generate in one call? 10,000 per batch, and multiple batches per run via types. One batch is one $0.0004 charge no matter how many ids it holds.

Can I generate several id formats in a single run? Yes - {"types": ["v4", "v7", "ulid"], "count": 100} returns three records of 100 ids each. When types is set, the single type field is ignored.

Are these cryptographically random? Yes. v4 uses crypto.randomUUID; v7, ULID, NanoID and short all draw from crypto.randomBytes / randomFillSync. No Math.random anywhere.

What happens if I ask for a type you do not support? You get an ok: false record naming the valid types, and no charge. It never silently substitutes a different format.

Use from code or AI agents

curl -s "https://api.apify.com/v2/acts/EliAI~uuid-generator/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -X POST -H 'Content-Type: application/json' \
  -d '{"type": "v7", "count": 100}'

Agents: connect Apify MCP and call the EliAI/uuid-generator tool.

• Capability: bulk id generation - UUID v4 and v7, ULID, NanoID, short - CSPRNG-backed, one batch record per type
• Required input: none (type defaults to v4); types, count and uppercase are optional
• Returns: one batch record per type; ids and sortable are the payload
• Bounded: 10,000 ids per batch; unknown types isolate as free records
• Side effects: none