# UUID / GUID Generator (`automation-lab/uuid-generator`) Actor Generate bulk UUIDs and GUIDs in v1, v4, or v7 format. Configurable output with or without dashes, uppercase or lowercase. Export up to 100,000 UUIDs at once to CSV, JSON, or Excel. Fast, deterministic, and reliable for seeding databases or test data generation. - **URL**: https://apify.com/automation-lab/uuid-generator.md - **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community) - **Categories:** Developer tools, Automation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing Pay per event 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 / 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 | ```json { "count": 100, "version": "v4", "format": "standard", "uppercase": false } ```` #### Input examples **Generate 50 v7 UUIDs (time-ordered, with timestamps):** ```json { "count": 50, "version": "v7", "format": "standard", "uppercase": false } ``` **Generate 1,000 uppercase v4 UUIDs without dashes:** ```json { "count": 1000, "version": "v4", "format": "no-dashes", "uppercase": true } ``` **Generate 10 v1 UUIDs to see embedded timestamps:** ```json { "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) ```json { "uuid": "550e8400-e29b-41d4-a716-446655440000", "version": "v4", "index": 1 } ``` #### v7 UUID (time-ordered with timestamp) ```json { "uuid": "018e5b5f-d2a3-7b4c-9c8d-e1f2a3b4c5d6", "version": "v7", "index": 1, "timestamp": "2024-03-15T14:22:03.267Z" } ``` #### v1 UUID (time-based with timestamp) ```json { "uuid": "6ba7b810-9dad-11d1-80b4-00c04fd430c8", "version": "v1", "index": 1, "timestamp": "1998-02-04T22:13:53.788Z" } ``` #### Uppercase, no-dashes format ```json { "uuid": "550E8400E29B41D4A716446655440000", "version": "v4", "index": 1 } ``` ### How to generate UUIDs with UUID Generator 1. Go to [UUID Generator](https://apify.com/automation-lab/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 ```javascript 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 ```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 ```bash 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: ```bash 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 ```bash 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: ```json { "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](https://docs.apify.com/platform/integrations/mcp). ### 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](https://apify.com/automation-lab/hash-generator) โ€” Generate MD5, SHA-1, SHA-256, and SHA-512 hashes for strings - [GitHub Scraper](https://apify.com/automation-lab/github-scraper) โ€” Repositories, profiles, trending, and search results from GitHub - [Stack Overflow Scraper](https://apify.com/automation-lab/stackoverflow-scraper) โ€” Questions, answers, and tags from Stack Overflow - [npm Scraper](https://apify.com/automation-lab/npm-scraper) โ€” Package metadata from the npm registry - [Hacker News Scraper](https://apify.com/automation-lab/hackernews-scraper) โ€” Stories from Hacker News with comments and metadata - [PyPI Scraper](https://apify.com/automation-lab/pypi-scraper) โ€” Python package data from PyPI including downloads and version history - [Crates Scraper](https://apify.com/automation-lab/crates-scraper) โ€” Rust crate metadata from crates.io with download statistics - [GitHub Trending Scraper](https://apify.com/automation-lab/github-trending-scraper) โ€” Trending repositories from GitHub with star velocity and language filters # Actor input Schema ## `count` (type: `integer`): How many UUIDs to generate. Minimum 1, maximum 100,000. ## `version` (type: `string`): UUID version to generate. v1 = time-based, v4 = random, v7 = time-ordered random (newest standard). ## `format` (type: `string`): Format for the generated UUIDs. 'standard' includes dashes (e.g. 550e8400-e29b-41d4-a716-446655440000), 'no-dashes' removes them. ## `uppercase` (type: `boolean`): When enabled, UUIDs are returned in uppercase (e.g. 550E8400-E29B-41D4-A716-446655440000). ## Actor input object example ```json { "count": 10, "version": "v4", "format": "standard", "uppercase": false } ``` # Actor output Schema ## `overview` (type: `string`): No description # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "count": 10, "version": "v4", "format": "standard", "uppercase": false }; // Run the Actor and wait for it to finish const run = await client.actor("automation-lab/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "count": 10, "version": "v4", "format": "standard", "uppercase": False, } # Run the Actor and wait for it to finish run = client.actor("automation-lab/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 '{ "count": 10, "version": "v4", "format": "standard", "uppercase": false }' | apify call automation-lab/uuid-generator --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=automation-lab/uuid-generator", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "UUID / GUID Generator", "description": "Generate bulk UUIDs and GUIDs in v1, v4, or v7 format. Configurable output with or without dashes, uppercase or lowercase. Export up to 100,000 UUIDs at once to CSV, JSON, or Excel. Fast, deterministic, and reliable for seeding databases or test data generation.", "version": "0.1", "x-build-id": "DqpwiZZ7hVqinSrEE" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/automation-lab~uuid-generator/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~uuid-generator/runs": { "post": { "operationId": "runs-sync-automation-lab-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/automation-lab~uuid-generator/run-sync": { "post": { "operationId": "run-sync-automation-lab-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", "properties": { "count": { "title": "๐Ÿ”ข Number of UUIDs to generate", "minimum": 1, "maximum": 100000, "type": "integer", "description": "How many UUIDs to generate. Minimum 1, maximum 100,000.", "default": 10 }, "version": { "title": "UUID version", "enum": [ "v1", "v4", "v7" ], "type": "string", "description": "UUID version to generate. v1 = time-based, v4 = random, v7 = time-ordered random (newest standard).", "default": "v4" }, "format": { "title": "Output format", "enum": [ "standard", "no-dashes" ], "type": "string", "description": "Format for the generated UUIDs. 'standard' includes dashes (e.g. 550e8400-e29b-41d4-a716-446655440000), 'no-dashes' removes them.", "default": "standard" }, "uppercase": { "title": "Uppercase", "type": "boolean", "description": "When enabled, UUIDs are returned in uppercase (e.g. 550E8400-E29B-41D4-A716-446655440000).", "default": false } } }, "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 } } } } } } } } } } ```