# RandomUser Test Data Scraper (`parseforge/randomuser-test-data-scraper`) Actor

Spin up lifelike synthetic users from randomuser.me with full names, emails, profile photos, phone numbers, and postal addresses. Filter by gender, nationality, or a fixed seed for reproducible mock data. Perfect for seeding test databases, QA fixtures, and product demos.

- **URL**: https://apify.com/parseforge/randomuser-test-data-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🧑‍💻 RandomUser Test Data Scraper

> 🚀 **Generate realistic mock users in one run.** Spin up clean, fully populated synthetic identities with names, emails, addresses, phone numbers, photos, and login fields, ready for your test suite, staging database, or demo.

> 🕒 **Last updated:** 2026-06-04 · **📊 31 fields** per record · powered by the public randomuser.me API · 21 nationalities supported

Need believable people for your app without touching a single real person's data? This actor turns the keyless randomuser.me API into a clean, structured feed of synthetic users. Pick how many you want, optionally lock a gender, a set of nationalities, or a reproducible seed, and get back a flat record per user with a profile photo, full name, email, username, phone, address, coordinates, date of birth, and a national ID placeholder.

Every value is fabricated by randomuser.me. Nothing here belongs to a real individual, which makes it safe to drop into test environments, fixtures, and demos. Use a seed when you need the exact same users on every run, or leave it blank for a fresh batch each time. Coverage spans 21 nationalities including the US, UK, Canada, Germany, France, Spain, Australia, Brazil, India, and more.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Backend and frontend developers | Seeding databases with mock users |
| QA and test automation engineers | Populating test fixtures and CI runs |
| Designers and demo builders | Filling UI mockups with lifelike data |
| Data and ML teams | Generating placeholder profiles at volume |

### 📋 What the RandomUser Test Data Scraper does

This actor calls the randomuser.me API and returns one clean record per synthetic user. It flattens the nested API response into simple columns so you can use the data immediately. You control the batch with a few inputs:

- **Number of Users** sets how many records to generate per run.
- **Seed** makes the output reproducible. The same seed always returns the same users.
- **Gender** restricts the batch to male or female, or leaves it mixed.
- **Nationalities** restricts the batch to one or more of 21 supported countries.

Each record includes a profile photo, a full name broken into title, first, and last, gender, email, a generated username and uuid, phone and cell numbers, a postal address with city, state, country, postcode, and map coordinates, a date of birth with age, an account registration date, a timezone, and a national ID placeholder such as a US SSN, a UK NINO, or a Canadian SIN.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `results` | integer | How many synthetic users to generate (default 10). |
| `seed` | string | Optional. The same seed reproduces the same users. |
| `maxItems` | integer | Optional cap on records. Free plan is limited to 10. |
| `gender` | select | Any, Male, or Female. |
| `nationalities` | array | One or more of 21 supported countries. |

Example 1 — ten mixed users, fresh every run:

```json
{
  "results": 10
}
````

Example 2 — twenty reproducible British and American women:

```json
{
  "results": 20,
  "gender": "female",
  "nationalities": ["GB", "US"],
  "seed": "qa-fixture-2026"
}
```

> ⚠️ **Good to Know:** when you set a `seed`, the gender filter is ignored by the source API and you may get a mix of genders. To force a single gender, run without a seed. All data is synthetic and not tied to any real person.

### 📊 Output

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Large profile photo URL |
| 👤 `fullName` | Title, first, and last name combined |
| 🏷 `title` | Honorific such as Mr, Ms, Mrs |
| 🔤 `firstName` | First name |
| 🔡 `lastName` | Last name |
| ⚧ `gender` | male or female |
| ✉ `email` | Email address |
| 🔑 `username` | Generated login username |
| 🆔 `uuid` | Unique user identifier |
| 📞 `phone` | Landline phone number |
| 📱 `cell` | Mobile phone number |
| 🌍 `nationality` | Two letter country code |
| 🎂 `dateOfBirth` | Birth date timestamp |
| 🔢 `age` | Age in years |
| 📅 `registeredDate` | Account registration timestamp |
| ⏳ `accountAgeYears` | Years since registration |
| 🏠 `street` | Street number and name |
| 🏙 `city` | City |
| 🗺 `state` | State or region |
| 🌐 `country` | Country |
| 📮 `postcode` | Postal code |
| 📍 `latitude` | Latitude |
| 📍 `longitude` | Longitude |
| 🕓 `timezoneOffset` | UTC offset |
| 🕰 `timezoneDescription` | Timezone description |
| 🪪 `idName` | National ID type such as SSN, NINO, SIN |
| 🔖 `idValue` | National ID placeholder value |
| 🖼 `pictureMedium` | Medium photo URL |
| 🖼 `pictureThumbnail` | Thumbnail photo URL |
| 🕒 `scrapedAt` | Generation timestamp |
| ❌ `error` | Error message, null on success |

Three real records from a live run:

```json
{
  "imageUrl": "https://randomuser.me/api/portraits/women/18.jpg",
  "fullName": "Ms Amy Steward",
  "title": "Ms",
  "firstName": "Amy",
  "lastName": "Steward",
  "gender": "female",
  "email": "amy.steward@example.com",
  "username": "tinyduck936",
  "uuid": "dcf9c825-2b70-4623-a1e3-e4129000d2a1",
  "phone": "0131 590 7144",
  "cell": "07724 405591",
  "nationality": "GB",
  "dateOfBirth": "1959-02-10T14:41:49.856Z",
  "age": 67,
  "registeredDate": "2004-05-19T08:58:37.838Z",
  "accountAgeYears": 22,
  "street": "5632 Station Road",
  "city": "Newcastle upon Tyne",
  "state": "Clwyd",
  "country": "United Kingdom",
  "postcode": "T45 0YL",
  "latitude": "-5.7939",
  "longitude": "-151.3291",
  "timezoneOffset": "+10:00",
  "timezoneDescription": "Eastern Australia, Guam, Vladivostok",
  "idName": "NINO",
  "idValue": "KJ 36 53 02 R",
  "pictureMedium": "https://randomuser.me/api/portraits/med/women/18.jpg",
  "pictureThumbnail": "https://randomuser.me/api/portraits/thumb/women/18.jpg",
  "scrapedAt": "2026-06-04T19:36:27.000Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://randomuser.me/api/portraits/women/74.jpg",
  "fullName": "Ms Sarah Chow",
  "title": "Ms",
  "firstName": "Sarah",
  "lastName": "Chow",
  "gender": "female",
  "email": "sarah.chow@example.com",
  "username": "blackelephant607",
  "uuid": "4b49abc3-68e4-4c43-a534-8f0c2760f73f",
  "phone": "I05 Z47-6158",
  "cell": "K31 B03-7028",
  "nationality": "CA",
  "dateOfBirth": "1952-05-21T09:06:50.026Z",
  "age": 74,
  "registeredDate": "2012-02-18T20:21:09.390Z",
  "accountAgeYears": 14,
  "street": "9086 Coastal Highway",
  "city": "Greenwood",
  "state": "Yukon",
  "country": "Canada",
  "postcode": "T0D 9B3",
  "latitude": "-26.3574",
  "longitude": "77.4107",
  "timezoneOffset": "-11:00",
  "timezoneDescription": "Midway Island, Samoa",
  "idName": "SIN",
  "idValue": "362089625",
  "pictureMedium": "https://randomuser.me/api/portraits/med/women/74.jpg",
  "pictureThumbnail": "https://randomuser.me/api/portraits/thumb/women/74.jpg",
  "scrapedAt": "2026-06-04T19:36:27.147Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://randomuser.me/api/portraits/women/74.jpg",
  "fullName": "Mrs Lucy Taylor",
  "title": "Mrs",
  "firstName": "Lucy",
  "lastName": "Taylor",
  "gender": "female",
  "email": "lucy.taylor@example.com",
  "username": "brownduck861",
  "uuid": "78a49e5f-9a8b-47e8-9d8e-5d0a63336c9c",
  "phone": "01074 96061",
  "cell": "07607 931928",
  "nationality": "GB",
  "dateOfBirth": "1988-06-15T03:41:05.234Z",
  "age": 37,
  "registeredDate": "2003-04-02T18:07:14.698Z",
  "accountAgeYears": 23,
  "street": "801 The Grove",
  "city": "Winchester",
  "state": "Grampian",
  "country": "United Kingdom",
  "postcode": "L2 1FG",
  "latitude": "38.0586",
  "longitude": "119.0621",
  "timezoneOffset": "-4:00",
  "timezoneDescription": "Atlantic Time (Canada), Caracas, La Paz",
  "idName": "NINO",
  "idValue": "TG 44 93 96 M",
  "pictureMedium": "https://randomuser.me/api/portraits/med/women/74.jpg",
  "pictureThumbnail": "https://randomuser.me/api/portraits/thumb/women/74.jpg",
  "scrapedAt": "2026-06-04T19:36:27.190Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Fully synthetic by design.** Every record is generated, so there is no real personal data and no privacy headache for your test environment.
- **Flat, ready to use.** The nested API response is flattened into 31 plain columns, so you can load it straight into a database or spreadsheet without reshaping.
- **Reproducible when you need it.** Lock a seed and get the exact same users on every run, which is ideal for stable test fixtures.
- **Photos included.** Each record carries a real profile photo URL in three sizes, perfect for filling avatar slots in mockups.
- **Multi nationality.** Pull from 21 countries with locale appropriate names, addresses, phone formats, and national ID types.

### 📈 How it compares to alternatives

| Approach | Setup effort | Realistic photos | Reproducible | Flattened output |
|---|---|---|---|---|
| This Actor | Minimal | Yes | Yes, via seed | Yes |
| Writing your own faker script | Medium | Usually no | Depends | You build it |
| Copying production data | High and risky | Yes | No | No |
| Hand typing test users | Very high | No | No | No |

### 🚀 How to use

1. Sign up for a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the RandomUser Test Data Scraper and set the number of users you want.
3. Optionally pick a gender, one or more nationalities, and a seed for reproducibility.
4. Click **Start** and let the run finish.
5. Preview the generated users, then connect the dataset to your app or integration.

### 💼 Business use cases

#### Software development

| Need | How this helps |
|---|---|
| Seed a staging database | Drop in dozens of believable users with full profiles |
| Build UI before real data exists | Fill name, email, and avatar slots with lifelike values |

#### Quality assurance

| Need | How this helps |
|---|---|
| Stable test fixtures | Use a seed to get identical users on every CI run |
| Edge case coverage | Pull varied nationalities to test address and phone formats |

#### Demos and sales

| Need | How this helps |
|---|---|
| Product demos | Populate dashboards with realistic looking customer lists |
| Onboarding screenshots | Generate clean sample accounts on demand |

#### Training and education

| Need | How this helps |
|---|---|
| Teaching data handling | Practice on safe synthetic profiles, not real records |
| Workshop datasets | Hand out reproducible user sets to every attendee |

### 🔌 Automating RandomUser Test Data Scraper

Connect the output to your stack so fresh test data flows automatically:

- **Make** and **Zapier** to push generated users into apps and sheets.
- **Slack** to post a batch summary when a run finishes.
- **Airbyte** to load records into a warehouse for analytics fixtures.
- **GitHub** Actions to refresh test fixtures on a schedule.
- **Google Drive** to archive generated batches as snapshots.

### 🌟 Beyond business use cases

- **Research.** Build sample cohorts for survey tooling or interface studies.
- **Personal projects.** Fill a side project with believable users while you build.
- **Non-profit.** Stand up demo environments for volunteers without exposing real data.
- **Experimentation.** Stress test forms, validation, and rendering with varied inputs.

### 🤖 Ask an AI assistant

Drop the output into your favorite assistant and ask it to summarize, reshape, or generate code around it:

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

### ❓ Frequently Asked Questions

**Is the data real?**
No. Every user is fully synthetic and generated by the randomuser.me API. No record belongs to a real person.

**Can I get the same users on every run?**
Yes. Set a `seed` value and the same set of users is returned each time you run with that seed.

**Why did my gender filter return a mix of genders?**
The source API ignores the gender filter when a seed is supplied. Run without a seed to force a single gender.

**How many users can I generate per run?**
You can request up to 5000 per run. Free plan accounts are limited to 10 records as a preview.

**Which countries are supported?**
Twenty one nationalities including the US, UK, Canada, Australia, Germany, France, Spain, Brazil, India, Mexico, Netherlands, and more.

**Do records include a profile photo?**
Yes. Each record carries large, medium, and thumbnail photo URLs.

**What is the idValue field?**
It is a synthetic national ID placeholder whose type depends on nationality, such as a US SSN, a UK NINO, or a Canadian SIN.

**Are passwords included?**
No. Login passwords and hashes from the source are intentionally excluded to keep the output focused on identity fields.

**Can I use this data in production?**
It is meant for testing, demos, and development. Because values are synthetic, they should not be used as real customer records.

**How current is the data?**
Each run generates fresh data on demand, so there is no staleness to worry about.

**What does the error field mean?**
It is null on success. If a run fails, the error field carries a short message describing what went wrong.

**Can I restrict to specific nationalities and a gender at once?**
Yes, as long as you do not also set a seed. Combine the nationalities list with a gender for a targeted batch.

### 🔌 Integrate with any app

The dataset is available through the Apify API, so you can pull generated users into any system that speaks HTTP. Trigger runs on a schedule, fetch results programmatically, and wire them into your test pipelines.

### 🔗 Recommended Actors

- [Agify Name Demographics Scraper](https://apify.com/parseforge/agify-name-demographics-scraper) to enrich names with predicted age data.
- [SWAPI Star Wars Scraper](https://apify.com/parseforge/swapi-star-wars-scraper) for another clean source of structured sample data.
- [Disposable Email Domains Scraper](https://apify.com/parseforge/disposable-email-domains-scraper) to validate and filter throwaway email addresses.
- [Datamuse Words Scraper](https://apify.com/parseforge/datamuse-words-scraper) for word lists useful in generated content and fixtures.
- [OpenTDB Trivia Scraper](https://apify.com/parseforge/opentdb-trivia-scraper) for sample question and answer data.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with randomuser.me. Only publicly available, synthetic data is generated.

# Actor input Schema

## `results` (type: `integer`):

How many synthetic user records to generate in one run.

## `seed` (type: `string`):

Optional seed string. The same seed always reproduces the same set of users. Leave empty for a fresh random set every run.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000. When set, it caps the number of generated users.

## `gender` (type: `string`):

Restrict generated users to a single gender. Leave as Any for a mix.

## `nationalities` (type: `array`):

Restrict generated users to one or more nationalities. Leave empty for any nationality.

## Actor input object example

```json
{
  "results": 10,
  "maxItems": 10,
  "gender": ""
}
```

# Actor output Schema

## `results` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "results": 10,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/randomuser-test-data-scraper").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 = {
    "results": 10,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/randomuser-test-data-scraper").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 '{
  "results": 10,
  "maxItems": 10
}' |
apify call parseforge/randomuser-test-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/randomuser-test-data-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RandomUser Test Data Scraper",
        "description": "Spin up lifelike synthetic users from randomuser.me with full names, emails, profile photos, phone numbers, and postal addresses. Filter by gender, nationality, or a fixed seed for reproducible mock data. Perfect for seeding test databases, QA fixtures, and product demos.",
        "version": "0.1",
        "x-build-id": "1Dbwf8j3mD6ecxoDn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~randomuser-test-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-randomuser-test-data-scraper",
                "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/parseforge~randomuser-test-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-randomuser-test-data-scraper",
                "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/parseforge~randomuser-test-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-randomuser-test-data-scraper",
                "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": {
                    "results": {
                        "title": "Number of Users",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many synthetic user records to generate in one run."
                    },
                    "seed": {
                        "title": "Seed",
                        "type": "string",
                        "description": "Optional seed string. The same seed always reproduces the same set of users. Leave empty for a fresh random set every run."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000. When set, it caps the number of generated users."
                    },
                    "gender": {
                        "title": "Gender",
                        "enum": [
                            "",
                            "male",
                            "female"
                        ],
                        "type": "string",
                        "description": "Restrict generated users to a single gender. Leave as Any for a mix.",
                        "default": ""
                    },
                    "nationalities": {
                        "title": "Nationalities",
                        "type": "array",
                        "description": "Restrict generated users to one or more nationalities. Leave empty for any nationality.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AU",
                                "BR",
                                "CA",
                                "CH",
                                "DE",
                                "DK",
                                "ES",
                                "FI",
                                "FR",
                                "GB",
                                "IE",
                                "IN",
                                "IR",
                                "MX",
                                "NL",
                                "NO",
                                "NZ",
                                "RS",
                                "TR",
                                "UA",
                                "US"
                            ],
                            "enumTitles": [
                                "Australia",
                                "Brazil",
                                "Canada",
                                "Switzerland",
                                "Germany",
                                "Denmark",
                                "Spain",
                                "Finland",
                                "France",
                                "United Kingdom",
                                "Ireland",
                                "India",
                                "Iran",
                                "Mexico",
                                "Netherlands",
                                "Norway",
                                "New Zealand",
                                "Serbia",
                                "Turkey",
                                "Ukraine",
                                "United States"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
