UUID / GUID Generator

Generate thousands of UUIDs instantly — v1 (time-based), v4 (random), or v7 (time-ordered). Download as JSON, CSV, or Excel. Use via API, schedule runs, or connect to Make, Zapier, and n8n.

What does UUID Generator do?

UUID Generator is a bulk UUID/GUID generation tool that produces thousands of unique identifiers in a single run. Choose from three UUID versions — v1, v4, or v7 — and configure output format (standard with dashes, no-dashes, uppercase) to match your system's requirements.

Every UUID is generated using the RFC 4122 standard. The actor outputs one dataset item per UUID, making results easy to download, paginate, and process downstream. For time-based versions (v1 and v7), the embedded timestamp is decoded and included as a human-readable ISO 8601 field.

Whether you need 10 UUIDs for a quick test or 100,000 for a bulk database seed, UUID Generator handles it in seconds at a fraction of the cost of custom code setup.

Who is it for?

• 🏗️ Backend developers — seeding databases with primary keys during development and testing
• 🔧 DevOps engineers — generating unique identifiers for configuration management, deployment artifacts, or infrastructure IDs
• 📊 Data engineers — creating unique record identifiers for ETL pipelines, data warehousing, and de-duplication
• 🧪 QA engineers — generating large sets of unique test IDs for load testing, fixture data, and test case labeling
• 🔌 API integrators — producing idempotency keys, correlation IDs, and request tracking identifiers in bulk
• 🤖 Automation builders — using Make, Zapier, or n8n to inject UUID batches into downstream workflows
• 💡 Architects — comparing v1/v4/v7 timestamp and ordering behavior for distributed systems design

Why use UUID Generator?

• Three UUID versions — v1 (time + MAC), v4 (fully random), v7 (time-ordered random, newest standard)
• Bulk generation — produce up to 100,000 UUIDs in a single run instead of writing throwaway scripts
• Format flexibility — choose standard dashes, no-dashes, or uppercase to match your target system's format requirements
• Timestamp extraction — v1 and v7 UUIDs include the embedded timestamp decoded to ISO 8601 for easy auditing
• Structured output — one dataset item per UUID with index, version, and optional timestamp field
• API and integration ready — call programmatically, schedule recurring generation runs, or integrate with Make, Zapier, n8n
• Pay-per-event pricing — only $0.0001 per UUID generated, plus a low one-time start fee of $0.01

UUID versions explained

Version	Method	Ordered?	Timestamp?	Best for
v1	Time + MAC address	No (time encoded, not sortable)	Yes (decoded to ISO 8601)	Audit trails, time-correlated records
v4	Fully random	No	No	General-purpose primary keys, tokens
v7	Time-ordered + random	Yes (sortable by creation time)	Yes (decoded to ISO 8601)	Database primary keys, event sourcing

Recommendation: Use v7 for new systems that benefit from index locality in databases (PostgreSQL, MySQL). Use v4 for maximum randomness and compatibility. Use v1 when you need to recover the generation timestamp from the UUID itself.

Input parameters

Parameter	Type	Required	Default	Description
count	integer	No	10	Number of UUIDs to generate (1–100,000)
version	string	No	"v4"	UUID version: "v1", "v4", or "v7"
format	string	No	"standard"	Output format: "standard" (with dashes) or "no-dashes"
uppercase	boolean	No	false	Return UUIDs in uppercase

{
    "count": 100,
    "version": "v4",
    "format": "standard",
    "uppercase": false
}

Input examples

Generate 50 v7 UUIDs (time-ordered, with timestamps):

{
    "count": 50,
    "version": "v7",
    "format": "standard",
    "uppercase": false
}

Generate 1,000 uppercase v4 UUIDs without dashes:

{
    "count": 1000,
    "version": "v4",
    "format": "no-dashes",
    "uppercase": true
}

Generate 10 v1 UUIDs to see embedded timestamps:

{
    "count": 10,
    "version": "v1",
    "format": "standard",
    "uppercase": false
}

Output fields

Each dataset item contains the following fields:

Field	Type	Description
uuid	string	The generated UUID (formatted per your settings)
version	string	UUID version used: "v1", "v4", or "v7"
index	integer	Sequential position in the batch (1-based)
timestamp	string	ISO 8601 timestamp decoded from the UUID (v1 and v7 only)

Note: timestamp is only present for v1 and v7 UUIDs. v4 UUIDs have no embedded time information.

Output examples

v4 UUID (standard format)

{
    "uuid": "550e8400-e29b-41d4-a716-446655440000",
    "version": "v4",
    "index": 1
}

v7 UUID (time-ordered with timestamp)

{
    "uuid": "018e5b5f-d2a3-7b4c-9c8d-e1f2a3b4c5d6",
    "version": "v7",
    "index": 1,
    "timestamp": "2024-03-15T14:22:03.267Z"
}

v1 UUID (time-based with timestamp)

{
    "uuid": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
    "version": "v1",
    "index": 1,
    "timestamp": "1998-02-04T22:13:53.788Z"
}

Uppercase, no-dashes format

{
    "uuid": "550E8400E29B41D4A716446655440000",
    "version": "v4",
    "index": 1
}

How to generate UUIDs with UUID Generator

1. Go to UUID Generator on Apify Store
2. Set the number of UUIDs to generate (default: 10, max: 100,000)
3. Select the UUID version: v1, v4, or v7
4. Choose output format: standard dashes, no-dashes, uppercase
5. Click Start and wait a few seconds for results
6. Download the UUIDs as JSON, CSV, or Excel from the dataset

How much does it cost to generate UUIDs?

UUID Generator uses pay-per-event pricing. You only pay for UUIDs actually generated.

Event	Price	Notes
Start	$0.01	One-time per run
UUID generated	$0.0001	Per UUID

Example costs:

UUIDs	Start fee	Generation fee	Total
10	$0.01	$0.001	$0.011
100	$0.01	$0.01	$0.02
1,000	$0.01	$0.10	$0.11
10,000	$0.01	$1.00	$1.01
100,000	$0.01	$10.00	$10.01

Apify provides a free tier that covers approximately $5 of usage per month. This gives you roughly 49,900 UUIDs free per month (after the $0.01 start fee).

Using the Apify API

You can start UUID Generator programmatically from your own applications using the Apify API. Below are examples in Node.js, Python, and cURL.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('automation-lab/uuid-generator').call({
    count: 100,
    version: 'v4',
    format: 'standard',
    uppercase: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map(item => item.uuid));

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')

run = client.actor('automation-lab/uuid-generator').call(run_input={
    'count': 100,
    'version': 'v4',
    'format': 'standard',
    'uppercase': False,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
uuids = [item['uuid'] for item in items]
print(uuids)

cURL

curl -X POST "https://api.apify.com/v2/acts/automation-lab~uuid-generator/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "count": 100,
    "version": "v4",
    "format": "standard",
    "uppercase": false
  }'

After the run completes, fetch results from the dataset:

$curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_TOKEN"

Integrations

UUID Generator integrates with the full Apify platform ecosystem and external automation tools.

Make (formerly Integromat)

• Trigger UUID generation as a step in a scenario
• Use generated UUIDs as idempotency keys in subsequent API calls
• Store UUID batches in Google Sheets or Airtable

Zapier

• Generate UUIDs when a new record is created in your CRM or database
• Add UUIDs as unique identifiers to records in HubSpot, Salesforce, or Notion
• Send UUID batches to Google Drive as CSV exports

n8n

• Self-hosted UUID generation pipeline using the Apify node
• Combine UUID generation with database insert workflows
• Schedule regular UUID batch generation for pre-seeding test environments

Google Sheets

• Export UUID datasets directly to spreadsheets via Apify's Google Sheets integration
• Use as lookup tables or reference data for other automation workflows

Webhooks

• Send UUID batches to any HTTP endpoint via Apify's webhook feature
• Trigger downstream services to ingest new UUIDs immediately after generation

Scheduled runs

• Pre-generate UUID pools on a schedule (e.g., daily) for high-throughput systems
• Replenish UUID inventory for pre-allocation patterns in distributed architectures

Tips and best practices

• Use v7 for new database primary keys — v7 UUIDs are time-ordered, which improves B-tree index performance compared to random v4 UUIDs. PostgreSQL and MySQL both benefit significantly from sequential inserts.
• Use v4 for security tokens and API keys — fully random v4 UUIDs provide maximum unpredictability for session tokens, CSRF tokens, and API keys.
• Use v1 sparingly — v1 UUIDs embed the MAC address of the generating machine, which may leak hardware information in public-facing contexts. Prefer v4 or v7 for new designs.
• No-dashes format for storage efficiency — if you store UUIDs as plain strings (not the native UUID type), removing dashes saves 4 bytes per UUID and may simplify comparisons in some languages.
• Uppercase for legacy systems — some older systems or databases store UUIDs as uppercase. Match the format of your target system to avoid case-mismatch bugs in queries.
• Generate in batches, not one at a time — for large volumes, a single run of UUID Generator is far more efficient than calling an API endpoint once per UUID.
• Use timestamps to correlate v7 events — the decoded timestamp field in v7 output lets you trace when a UUID was generated, useful for debugging distributed systems or event sourcing pipelines.
• Combine with other actors — pipe UUID output into a database seeding workflow, or use UUIDs as idempotency keys in web scraping pipelines.

Use with Claude AI (MCP)

This actor is available as a tool in Claude AI through the Model Context Protocol (MCP). Add it to Claude Desktop, Cursor, Windsurf, or any MCP-compatible client.

Setup for Claude Code

$claude mcp add --transport http apify "https://mcp.apify.com"

Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}

Example prompts

• "Generate 100 v7 UUIDs for database seeding and show me the embedded timestamps."
• "I need 1,000 UUIDs in uppercase no-dashes format for this legacy system — generate them as a CSV."
• "Generate 20 v4 UUIDs to use as idempotency keys for my API requests."

Learn more in the Apify MCP documentation.

Legality

UUID generation does not involve scraping, accessing third-party services, or processing personal data. All UUIDs are generated locally using standard algorithms (RFC 4122 / draft-peabody-dispatch-new-uuid-format). No external requests are made during generation. There are no legal restrictions on UUID generation.

FAQ

What is the difference between UUID v1, v4, and v7? v1 uses the current timestamp and the MAC address of the generating machine — it includes time information but is not ordered. v4 is fully random with no time component — the most commonly used version. v7 (newest, 2024 standard) uses a Unix timestamp as the high bits, making it naturally sortable by creation time while still including sufficient random bits for uniqueness.

Are the generated UUIDs truly unique? v4 UUIDs have 122 bits of randomness, giving a collision probability of approximately 1 in 10^18 for a billion UUIDs. v7 UUIDs have slightly fewer random bits (about 74) but are generated in sub-millisecond intervals, making collisions astronomically unlikely in practice. v1 UUIDs use time + MAC address, which guarantees uniqueness as long as the clock does not go backward.

What is a GUID? Is it the same as a UUID? GUID (Globally Unique Identifier) is Microsoft's name for UUID. They follow the same RFC 4122 standard and are interchangeable. The two terms refer to the same 128-bit identifier format.

Can I use these UUIDs as database primary keys? Yes. UUIDs are widely used as primary keys in PostgreSQL (native UUID type), MySQL (CHAR(36) or BINARY(16)), MongoDB, and most other databases. For best index performance, use v7 UUIDs — their time-ordered prefix reduces B-tree fragmentation compared to random v4 UUIDs.

Why does v7 have better database performance than v4? Database indexes (B-trees) perform best when new rows are inserted in roughly sorted order. Random v4 UUIDs cause frequent page splits and fragmentation as inserts land at arbitrary positions in the index. v7 UUIDs sort by creation time, so new inserts are always appended to the end of the index — similar to an auto-increment integer.

Can I generate UUIDs with a specific namespace (v3 or v5)? UUID v3 (MD5) and v5 (SHA-1) are namespace-based and require an input namespace UUID and name. This actor does not support v3/v5. For namespace-based UUIDs, use the uuid npm package directly in your application code.

The run completed but my dataset has fewer UUIDs than I requested. This should not happen. If you see a discrepancy, check the run logs for any errors. The actor generates UUIDs in batches of 1,000 and pushes each batch to the dataset — a partial run would show in the logs. If the run was terminated early due to timeout, increase the timeout in run options.

Can I download the UUIDs as a plain text file, one per line? The dataset API supports multiple formats. Use the format=csv query parameter on the dataset items endpoint to get CSV output, then extract the uuid column. Alternatively, use format=json and process the JSON array in your application.

How long does it take to generate 100,000 UUIDs? UUID generation is CPU-bound but very fast. Generating 100,000 UUIDs typically completes in under 30 seconds, with most time spent pushing data to the Apify dataset in batches.

Are the UUIDs stored anywhere after the run? UUIDs are stored in the Apify dataset attached to your run. Datasets are retained per your Apify account's data retention policy (default 7 days for free plans, longer for paid plans). Download your dataset immediately after the run if you need the data long-term.

Is UUID v7 part of the official RFC standard? Yes. UUID version 7 was ratified in RFC 9562 (published May 2024), which supersedes RFC 4122. It is now an official IETF standard. All modern UUID libraries (including the uuid npm package v9+) support it.

Can I verify a UUID I generated here against a UUID validator? Yes. Standard UUID validators check format compliance (correct length, hyphen positions, and version/variant nibbles). UUIDs generated by this actor are fully RFC 9562 compliant. You can verify using online tools like uuidtools.com or the uuid validate function in the uuid npm package.

Why does the timestamp in a v1 UUID look like a historical date? The uuid npm package's v1 implementation may use a simulated clock state. This is normal — v1 UUIDs encode time since the UUID epoch (October 15, 1582) and the extracted timestamp is a real representation of when the UUID was generated. If you see timestamps from the 1990s, it means the library is using a clock state derived from a reference time. For reliable current timestamps, prefer v7.

Other developer tools

• Hash Generator — Generate MD5, SHA-1, SHA-256, and SHA-512 hashes for strings
• GitHub Scraper — Repositories, profiles, trending, and search results from GitHub
• Stack Overflow Scraper — Questions, answers, and tags from Stack Overflow
• npm Scraper — Package metadata from the npm registry
• Hacker News Scraper — Stories from Hacker News with comments and metadata
• PyPI Scraper — Python package data from PyPI including downloads and version history
• Crates Scraper — Rust crate metadata from crates.io with download statistics
• GitHub Trending Scraper — Trending repositories from GitHub with star velocity and language filters