# UUID Generator (`maximedupre/uuid-generator`) Actor

Generate UUID v1, v3, v4, v5, v7, alphanumeric IDs, and sequential IDs in bulk. Validate, analyze, convert, deduplicate, and summarize UUIDs, then export clean results from Apify.

- **URL**: https://apify.com/maximedupre/uuid-generator.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 processed ids

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### 🔑 UUID generator for bulk IDs and validation

UUID Generator creates UUIDs, GUID-style identifiers, alphanumeric IDs, and sequential IDs for apps, databases, tests, migrations, and automation workflows. Use it as a bulk UUID generator for UUID v1, v3, v4, v5, and v7, or as a UUID utility to validate, analyze, convert, deduplicate, and summarize existing UUID values.

For a quick first run, keep the default input. It generates 1,536 standard UUID v4 values and saves one dataset item per ID. You can then raise or lower the count, switch to UUID v7, create deterministic UUID v3/v5 values from names and namespaces, or paste existing UUIDs for validation and conversion.

The Actor runs locally inside Apify. It does not need cookies, accounts, API keys, a source website, a browser extension, or an external UUID service. Results are available in the Apify dataset, so you can export JSON, CSV, Excel, XML, RSS, or HTML, call the run through the API, schedule it, or connect it to a webhook or integration.

### ✅ What this UUID generator does

- Generates UUID v1, UUID v3, UUID v4, UUID v5, and UUID v7.
- Generates alphanumeric IDs with your length, character set, prefix, and suffix.
- Generates sequential IDs with start, step, padding, prefix, suffix, and optional timestamp prefix.
- Creates deterministic UUID v3 and UUID v5 values from DNS, URL, OID, X.500, or custom namespace UUIDs.
- Converts UUID values between standard, uppercase, lowercase, no-hyphen, braces, and URN formats.
- Validates UUID strings and returns a clear mechanical reason for invalid UUIDs.
- Analyzes UUID version, variant, detected format, and embedded timestamps for time-based UUIDs.
- Checks duplicate UUID values and returns duplicate counts with submitted positions.
- Summarizes submitted UUID collections by validity, unique values, identifier type, and format.
- Saves one clean output item per generated or processed result.

### 📊 Data you get

Each dataset item represents one generated ID, processed UUID, duplicate group, or summary. Rows can include:

| Field | Description |
| --- | --- |
| `operation` | Job that produced the item, such as `generate`, `validate`, `analyze`, `convert`, `checkDuplicates`, or `summarize`. |
| `index` | 1-based generated or submitted item position when the item maps to one value. |
| `value` | Generated ID, submitted UUID, converted UUID, or duplicated UUID value. |
| `originalValue` | Submitted UUID before conversion. |
| `identifierType` | Generated or detected type, such as `uuid_v4`, `uuid_v7`, `alphanumeric`, or `sequential`. |
| `format` | UUID format such as `standard`, `uppercase`, `noHyphens`, `braces`, or `urn`. |
| `isValid`, `invalidReason` | UUID validation result and reason when a UUID is invalid. |
| `variant`, `uuidTimestamp` | UUID variant and embedded timestamp when available. |
| `generatedAt` | Generation timestamp for generated IDs. |
| `namespace`, `name` | Deterministic UUID v3/v5 source values. |
| `duplicateCount`, `duplicateIndexes` | Duplicate group size and submitted positions for duplicate checks. |
| `summary` | Collection totals for summarize runs. |

### 🚀 How to run it

1. Open the Actor input.
2. Choose **Operation**.
3. For generation, choose **Identifier type**, set **Number of identifiers**, and adjust format or deterministic/custom ID settings if needed.
4. For validation, analysis, conversion, duplicate checks, or summaries, paste values into **UUID values**.
5. Start the Actor and open the dataset.

Use **Generate identifiers** for seed data, test IDs, job IDs, database IDs, and workflow references. Use **Validate UUIDs** or **Analyze UUIDs** when you need to clean imported data. Use **Convert UUID format** when another system expects URN, braces, uppercase, lowercase, or no-hyphen UUIDs.

### 🧾 Input examples

Generate 25 UUID v7 values:

```json
{
	"operation": "generate",
	"identifierType": "uuid_v7",
	"count": 25,
	"valueFormat": "standard"
}
````

Generate deterministic UUID v5 values:

```json
{
	"operation": "generate",
	"identifierType": "uuid_v5",
	"namespace": "dns",
	"names": ["example.com", "user-{{index}}"],
	"count": 2
}
```

Validate existing UUID values:

```json
{
	"operation": "validate",
	"uuids": [
		"550e8400-e29b-41d4-a716-446655440000",
		"urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8",
		"not-a-uuid"
	]
}
```

### 📤 Output example

```json
{
	"operation": "analyze",
	"index": 1,
	"value": "550e8400-e29b-41d4-a716-446655440000",
	"originalValue": null,
	"identifierType": "uuid_v4",
	"format": "standard",
	"isValid": true,
	"invalidReason": null,
	"variant": "rfc4122",
	"uuidTimestamp": null,
	"generatedAt": null,
	"namespace": null,
	"name": null,
	"duplicateCount": null,
	"duplicateIndexes": [],
	"summary": null
}
```

Summary runs return the same stable row shape with `summary` filled:

```json
{
	"total": 3,
	"valid": 2,
	"invalid": 1,
	"unique": 2,
	"duplicateValues": 1,
	"byIdentifierType": {
		"uuid_v4": 2
	},
	"byFormat": {
		"standard": 2,
		"custom": 1
	}
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each processed ID saved to the dataset. A processed ID can be a generated UUID or custom ID, a validation or analysis item, a converted UUID, a duplicate finding, or a summary item.

The local pricing artifact sets the `uuid-result` event at `$0.00001` per processed ID on every Apify tier. Runs that stop before saving output items do not add processed-ID charges.

### ⚠️ Limits and notes

- Generation count can be set from 1 to 5,000,000.
- Submitted UUID lists and deterministic name lists are capped at 100,000 values.
- UUID v3 and UUID v5 are deterministic for the same namespace and name.
- UUID v1 and UUID v7 include timestamp-derived fields. UUID v4 and alphanumeric IDs use random values.
- Random UUID uniqueness follows the UUID standard and probability model. This Actor does not maintain a persistent global registry of every ID ever generated.
- Invalid UUIDs in validation and analysis runs are successful output items with `isValid: false`, so you can filter or export them.

### ❓ FAQ

#### 🔁 Can I use this as a GUID generator?

Yes. GUID and UUID are often used for the same 128-bit identifier format. Use UUID v4 for common random GUID-style values, or choose another UUID version when your system expects one.

#### 🕒 Can I generate UUID v7 values?

Yes. Choose `UUID v7` in **Identifier type**. The output includes `uuidTimestamp` when the timestamp can be mechanically extracted from the UUID.

#### 🔄 Can I convert UUIDs to no-hyphen or URN format?

Yes. Choose **Convert UUID format** and set **UUID value format** to `No hyphens`, `URN`, `Wrapped in braces`, uppercase, lowercase, or standard.

#### 🔐 Does this Actor call an external UUID API?

No. It runs as a local Apify Actor and does not need external credentials, cookies, source websites, or third-party UUID APIs.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~uuid-generator/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Unicode Text Inspector ↗](https://apify.com/maximedupre/unicode-text-inspector) - Audit text for hidden Unicode characters, bidi controls, and homoglyphs.
- [Profanity Checker ↗](https://apify.com/maximedupre/profanity-checker) - Check submitted text snippets for blocked words and cleaned output.
- [Email MX Verifier ↗](https://apify.com/maximedupre/email-mx-verifier) - Verify email syntax, MX records, disposable domains, and send decisions.
- [Sitemap Validator ↗](https://apify.com/maximedupre/sitemap-validator) - Check sitemap URLs, HTTP status, redirects, and sitemap metadata.
- [URL to BibTeX Converter ↗](https://apify.com/maximedupre/url-to-bibtex-converter) - Convert paper and web page URLs into BibTeX citation data.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `operation` (type: `string`):

Choose the identifier job for this run.

## `valueFormat` (type: `string`):

Choose the format for generated or converted UUID values.

## `identifierType` (type: `string`):

Choose which kind of identifier to generate.

## `count` (type: `integer`):

Set how many identifiers to generate.

## `names` (type: `array`):

Add names for UUID v3 or v5 generation.

## `nameTemplate` (type: `string`):

Set an indexed template for UUID v3 or v5 names.

## `namespace` (type: `string`):

Choose the namespace for UUID v3 or v5 generation.

## `customNamespace` (type: `string`):

Enter the namespace UUID used when Namespace is Custom namespace UUID.

## `prefix` (type: `string`):

Add text before generated alphanumeric or sequential IDs.

## `suffix` (type: `string`):

Add text after generated alphanumeric or sequential IDs.

## `alphanumericLength` (type: `integer`):

Set the number of random characters in each alphanumeric ID.

## `alphanumericCharset` (type: `string`):

Enter the characters available for alphanumeric IDs.

## `sequentialStart` (type: `integer`):

Set the first number for sequential IDs.

## `sequentialStep` (type: `integer`):

Set the increment between sequential IDs.

## `sequentialPadding` (type: `integer`):

Set the minimum number of digits for sequential IDs.

## `includeTimestampPrefix` (type: `boolean`):

Add the current timestamp before each sequential ID.

## `uuids` (type: `array`):

Add existing UUIDs for validation, analysis, conversion, duplicate checks, or summaries.

## Actor input object example

```json
{
  "operation": "generate",
  "valueFormat": "standard",
  "identifierType": "uuid_v4",
  "count": 1536,
  "names": [
    "example.com",
    "user-{{index}}"
  ],
  "nameTemplate": "item-{{index}}",
  "namespace": "dns",
  "customNamespace": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
  "prefix": "",
  "suffix": "",
  "alphanumericLength": 16,
  "alphanumericCharset": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
  "sequentialStart": 1,
  "sequentialStep": 1,
  "sequentialPadding": 6,
  "includeTimestampPrefix": false,
  "uuids": [
    "550e8400-e29b-41d4-a716-446655440000",
    "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8",
    "550e8400-e29b-41d4-a716-446655440000"
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

Generated IDs, validation results, analysis facts, converted UUIDs, duplicate findings, and summaries in the default dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "operation": "generate",
    "valueFormat": "standard",
    "identifierType": "uuid_v4",
    "count": 1536,
    "names": [
        "example.com",
        "user-{{index}}"
    ],
    "nameTemplate": "item-{{index}}",
    "namespace": "dns",
    "customNamespace": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
    "alphanumericLength": 16,
    "sequentialStart": 1,
    "sequentialStep": 1,
    "sequentialPadding": 6,
    "includeTimestampPrefix": false,
    "uuids": [
        "550e8400-e29b-41d4-a716-446655440000",
        "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8",
        "550e8400-e29b-41d4-a716-446655440000"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/uuid-generator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "operation": "generate",
    "valueFormat": "standard",
    "identifierType": "uuid_v4",
    "count": 1536,
    "names": [
        "example.com",
        "user-{{index}}",
    ],
    "nameTemplate": "item-{{index}}",
    "namespace": "dns",
    "customNamespace": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
    "alphanumericLength": 16,
    "sequentialStart": 1,
    "sequentialStep": 1,
    "sequentialPadding": 6,
    "includeTimestampPrefix": False,
    "uuids": [
        "550e8400-e29b-41d4-a716-446655440000",
        "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8",
        "550e8400-e29b-41d4-a716-446655440000",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/uuid-generator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "operation": "generate",
  "valueFormat": "standard",
  "identifierType": "uuid_v4",
  "count": 1536,
  "names": [
    "example.com",
    "user-{{index}}"
  ],
  "nameTemplate": "item-{{index}}",
  "namespace": "dns",
  "customNamespace": "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
  "alphanumericLength": 16,
  "sequentialStart": 1,
  "sequentialStep": 1,
  "sequentialPadding": 6,
  "includeTimestampPrefix": false,
  "uuids": [
    "550e8400-e29b-41d4-a716-446655440000",
    "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8",
    "550e8400-e29b-41d4-a716-446655440000"
  ]
}' |
apify call maximedupre/uuid-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/uuid-generator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UUID Generator",
        "description": "Generate UUID v1, v3, v4, v5, v7, alphanumeric IDs, and sequential IDs in bulk. Validate, analyze, convert, deduplicate, and summarize UUIDs, then export clean results from Apify.",
        "version": "0.0",
        "x-build-id": "BMXpplACQzEdbXHvM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~uuid-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-uuid-generator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~uuid-generator/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-uuid-generator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~uuid-generator/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-uuid-generator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "generate",
                            "validate",
                            "analyze",
                            "convert",
                            "checkDuplicates",
                            "summarize"
                        ],
                        "type": "string",
                        "description": "Choose the identifier job for this run.",
                        "default": "generate"
                    },
                    "valueFormat": {
                        "title": "UUID value format",
                        "enum": [
                            "standard",
                            "uppercase",
                            "lowercase",
                            "noHyphens",
                            "braces",
                            "urn"
                        ],
                        "type": "string",
                        "description": "Choose the format for generated or converted UUID values.",
                        "default": "standard"
                    },
                    "identifierType": {
                        "title": "Identifier type",
                        "enum": [
                            "uuid_v4",
                            "uuid_v7",
                            "uuid_v1",
                            "uuid_v3",
                            "uuid_v5",
                            "alphanumeric",
                            "sequential"
                        ],
                        "type": "string",
                        "description": "Choose which kind of identifier to generate.",
                        "default": "uuid_v4"
                    },
                    "count": {
                        "title": "Number of identifiers",
                        "minimum": 1,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Set how many identifiers to generate.",
                        "default": 1536
                    },
                    "names": {
                        "title": "Deterministic names",
                        "maxItems": 100000,
                        "type": "array",
                        "description": "Add names for UUID v3 or v5 generation.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 1000
                        }
                    },
                    "nameTemplate": {
                        "title": "Deterministic name template",
                        "minLength": 1,
                        "maxLength": 1000,
                        "type": "string",
                        "description": "Set an indexed template for UUID v3 or v5 names.",
                        "default": "item-{{index}}"
                    },
                    "namespace": {
                        "title": "UUID namespace",
                        "enum": [
                            "dns",
                            "url",
                            "oid",
                            "x500",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Choose the namespace for UUID v3 or v5 generation.",
                        "default": "dns"
                    },
                    "customNamespace": {
                        "title": "Custom namespace UUID",
                        "pattern": "^[0-9a-fA-F]{8}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{12}$",
                        "type": "string",
                        "description": "Enter the namespace UUID used when Namespace is Custom namespace UUID."
                    },
                    "prefix": {
                        "title": "Prefix",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Add text before generated alphanumeric or sequential IDs.",
                        "default": ""
                    },
                    "suffix": {
                        "title": "Suffix",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Add text after generated alphanumeric or sequential IDs.",
                        "default": ""
                    },
                    "alphanumericLength": {
                        "title": "Alphanumeric length",
                        "minimum": 1,
                        "maximum": 256,
                        "type": "integer",
                        "description": "Set the number of random characters in each alphanumeric ID.",
                        "default": 16
                    },
                    "alphanumericCharset": {
                        "title": "Alphanumeric character set",
                        "maxLength": 500,
                        "type": "string",
                        "description": "Enter the characters available for alphanumeric IDs.",
                        "default": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
                    },
                    "sequentialStart": {
                        "title": "Sequential start",
                        "type": "integer",
                        "description": "Set the first number for sequential IDs.",
                        "default": 1
                    },
                    "sequentialStep": {
                        "title": "Sequential step",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Set the increment between sequential IDs.",
                        "default": 1
                    },
                    "sequentialPadding": {
                        "title": "Sequential padding",
                        "minimum": 0,
                        "maximum": 32,
                        "type": "integer",
                        "description": "Set the minimum number of digits for sequential IDs.",
                        "default": 6
                    },
                    "includeTimestampPrefix": {
                        "title": "Include timestamp prefix",
                        "type": "boolean",
                        "description": "Add the current timestamp before each sequential ID.",
                        "default": false
                    },
                    "uuids": {
                        "title": "UUID values",
                        "minItems": 1,
                        "maxItems": 100000,
                        "type": "array",
                        "description": "Add existing UUIDs for validation, analysis, conversion, duplicate checks, or summaries.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 200
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
