# REST Countries Scraper - Country Data and Flags (`parseforge/restcountries-scraper`) Actor

Scrape country data including names, capitals, populations, currencies, languages, and flags from the REST Countries API. Export structured country records.

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

## Pricing

from $19.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)

## 🌍 RestCountries Scraper - Country Data, Flags, Currencies & More

> 🚀 **Export the complete world country database in seconds.** Get flags, capitals, populations, languages, currencies, timezones, and calling codes for all **250 countries** with zero auth required.

> 🕒 **Last updated:** 2026-05-21 · **📊 17 fields** per record · **🌍 250 countries** · **🗺️ 6 regions** · **🆓 No API key required**

The **RestCountries Scraper** pulls from the RestCountries v3.1 public API and returns **17 fields per record**, including the country flag image URL, official name, capital, geographic region, population, area, languages, currencies, timezones, international calling codes, and top-level domains. The underlying data is maintained by the open-source community and covers every sovereign state and territory recognized by the United Nations.

The catalog covers all 6 geographic regions (Africa, Americas, Asia, Europe, Oceania, Antarctic), 250 countries, and includes both the common name and the full official name of each country. This Actor returns a clean, structured dataset ready for download as CSV, Excel, JSON, or XML in seconds - no scraping engineering required.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Developers, data scientists, GIS analysts, educators, product teams, market researchers, e-commerce teams | Country dropdowns, phone validation, currency conversion, language detection, regional analysis, form autofill, academic research |

---

### 📋 What the RestCountries Scraper does

Four query workflows in a single run:

- 🌍 **Full export.** All 250 countries in one shot - flags, capitals, populations, and more.
- 🗺️ **Region filter.** Scope to Africa, Americas, Asia, Europe, Oceania, or Antarctic.
- 🔍 **Name search.** Find countries matching a full or partial name (e.g. "united" returns USA, UK, UAE, and more).
- 📦 **Controlled batch size.** Use `maxItems` to limit output for testing or tiered data products.

Each record includes the flag image URL, common and official name, capital city, region and subregion, population, area in km², official languages, currencies, timezones, international calling codes, top-level domain extensions, and a landlocked indicator.

> 💡 **Why it matters:** country reference data underlies every global product - from phone number validators to e-commerce checkout forms to analytics dashboards. Rolling your own means hardcoding 250 rows and maintaining it manually. This Actor delivers a live, structured export in one click.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded country dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan up to 1,000,000.</td></tr>
<tr><td><code>region</code></td><td>string</td><td><code>"all"</code></td><td>One of: all, africa, americas, asia, europe, oceania, antarctic.</td></tr>
<tr><td><code>search</code></td><td>string</td><td><code>""</code></td><td>Optional partial or full country name. Overrides region filter when set.</td></tr>
</tbody>
</table>

**Example: first 20 African countries.**

```json
{
    "maxItems": 20,
    "region": "africa"
}
````

**Example: search for countries containing "united".**

```json
{
    "maxItems": 10,
    "search": "united"
}
```

> ⚠️ **Good to Know:** when both `region` and `search` are provided, the `search` parameter takes priority. The RestCountries API performs partial name matching, so "ger" will return Germany, Algeria, and Niger. Set `maxItems` to a higher value if you expect multiple matches.

***

### 📊 Output

Each country record contains **17 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | `"https://flagcdn.com/w320/de.png"` |
| 🏷️ `name` | string | `"Germany"` |
| 📋 `officialName` | string | `"Federal Republic of Germany"` |
| 🏛️ `capital` | string | `"Berlin"` |
| 🌍 `region` | string | `"Europe"` |
| 🗺️ `subregion` | string | `"Western Europe"` |
| 👥 `population` | number | `83491249` |
| 📐 `area` | number | `357114` |
| 🗣️ `languages` | array | `["German"]` |
| 💰 `currencies` | array | `["euro"]` |
| 🕐 `timezones` | array | `["UTC+01:00"]` |
| 📞 `callingCodes` | array | `["+49"]` |
| 🌐 `tld` | array | `[".de"]` |
| 🏔️ `landlocked` | boolean | `false` |
| 🔗 `url` | string | `"https://restcountries.com/v3.1/name/Germany"` |
| 🕒 `scrapedAt` | string | `"2026-05-21T23:56:19.306Z"` |
| ❌ `error` | string | `null` |

#### 📄 Sample Records

```json
[
  {
    "imageUrl": "https://flagcdn.com/w320/si.png",
    "name": "Slovenia",
    "officialName": "Republic of Slovenia",
    "capital": "Ljubljana",
    "region": "Europe",
    "subregion": "Central Europe",
    "population": 2130638,
    "area": 20273,
    "languages": ["Slovene"],
    "currencies": ["euro"],
    "timezones": ["UTC+01:00"],
    "callingCodes": ["+386"],
    "tld": [".si"],
    "landlocked": false,
    "url": "https://restcountries.com/v3.1/name/Slovenia",
    "scrapedAt": "2026-05-21T23:56:19.306Z"
  },
  {
    "imageUrl": "https://flagcdn.com/w320/se.png",
    "name": "Sweden",
    "officialName": "Kingdom of Sweden",
    "capital": "Stockholm",
    "region": "Europe",
    "subregion": "Northern Europe",
    "population": 10605098,
    "area": 450295,
    "languages": ["Swedish"],
    "currencies": ["Swedish krona"],
    "timezones": ["UTC+01:00"],
    "callingCodes": ["+46"],
    "tld": [".se"],
    "landlocked": false,
    "url": "https://restcountries.com/v3.1/name/Sweden",
    "scrapedAt": "2026-05-21T23:56:19.306Z"
  }
]
```

***

### ✨ Why choose this Actor

- 🆓 **Zero auth.** No API keys, no registration, no billing setup - just run it.
- 🌍 **Complete coverage.** All 250 countries in a single API call - no pagination loops.
- 🖼️ **Flag images included.** Direct PNG URLs from flagcdn.com, ready to embed in any UI.
- 🔍 **Flexible filtering.** Scope by region or search by name - one input field each.
- 📦 **Structured arrays.** Languages, currencies, timezones, and calling codes returned as proper arrays, not comma-delimited strings.
- ⚡ **Sub-second collection.** Entire 250-country dataset collected in under 2 seconds.
- 💾 **4 export formats.** CSV, Excel, JSON, XML - download or connect via API.
- 🔌 **Webhook ready.** Trigger downstream workflows the moment data lands in the dataset.

***

### 📈 How it compares to alternatives

| Feature | This Actor | Manual CSV | REST API direct | Competitors |
|---|---|---|---|---|
| Flag image URLs | ✅ | - | ✅ raw | varies |
| Region filter | ✅ | ✗ | ✅ | varies |
| Name search | ✅ | ✗ | ✅ | varies |
| Clean array fields | ✅ | ✗ | ✗ raw objects | varies |
| CSV / Excel export | ✅ | ✅ | ✗ | varies |
| Webhook integration | ✅ | ✗ | ✗ | rarely |
| Free plan available | ✅ | - | ✅ | rarely |
| Zero engineering | ✅ | ✗ | ✗ | varies |

***

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify (no credit card required).
2. Open the **RestCountries Scraper** actor page and click **Try for free**.
3. Set `region` (or `search`) and `maxItems` in the input form.
4. Click **Start** and wait a few seconds.
5. Download your dataset as **CSV, Excel, JSON, or XML** from the Results tab.

***

### 💼 Business use cases

#### 🛒 E-commerce and checkout

Build international checkout forms that auto-populate country names, phone prefixes, and currency symbols. Use the `callingCodes` field to validate phone number inputs client-side and the `currencies` field to display localized pricing. Feed the `tld` array into email domain validation logic.

#### 📊 Market research and analytics

Segment global survey data by region or subregion without manual tagging. Join country records to your sales database using the `name` field as a key. Rank markets by `population` and `area` to prioritize expansion regions. Build choropleth maps using the structured country data with zero geocoding overhead.

#### 🖥️ Developer tools and reference APIs

Seed your database with a canonical country list on first deploy instead of maintaining a static JSON file. Build country picker dropdowns with flag images, official names, and ISO-compatible data. Power autocomplete endpoints that handle partial name searches across 250 countries. Validate user-submitted country names against the official dataset.

#### 🎓 Education and research

Build interactive world atlases with population and area data. Create geography quizzes using capitals and flags. Analyze language distribution across regions for computational linguistics work. Map landlocked countries for economics research on trade route dependencies.

***

### 🔌 Automating RestCountries Scraper

Connect this Actor to your favorite automation tools:

- **Make (Integromat):** Trigger a scenario when the dataset updates - push country data to Google Sheets, Notion, or Airtable automatically.
- **Zapier:** Send new country records to Slack, Salesforce, HubSpot, or any Zapier-connected app.
- **Webhooks:** Configure a webhook to POST dataset results to your own API the moment a run completes.
- **Apify API:** Schedule daily refreshes, download datasets programmatically, or integrate with your CI/CD pipeline.
- **n8n:** Chain the Actor output into transformation nodes and route country data to dozens of downstream services.

***

### 🌟 Beyond business use cases

#### 🔬 Research and academia

Linguists use the `languages` field to study which countries share official languages. Economists correlate `landlocked` status with GDP data. Demographers track `population` trends across subregions. Political scientists map regional bloc memberships using the `region` and `subregion` fields.

#### 🎨 Creative projects

Artists and designers build generative flag galleries using the `imageUrl` field. Game developers seed their world-builder databases with real country names and capitals. Writers building alternate-history fiction use the official country names and territories as a canonical baseline.

#### 🤝 Non-profit and civic tech

NGOs building humanitarian response tools need a reliable country list with calling codes for field communication. Open data projects use the dataset to enrich their own databases with language and currency metadata. Civic tech teams build multilingual government portals using the official country names.

#### 🧪 Experimentation and prototyping

Frontend developers prototype country picker components in minutes using live flag URLs and structured name data. Backend engineers test their internationalization stack against all 250 countries before launch. QA teams generate comprehensive test matrices for currency and timezone edge cases.

***

### 🤖 Ask an AI assistant about this scraper

Want to know how to integrate this data into your project? Ask your favorite AI:

- **ChatGPT:** "How do I use the RestCountries Scraper Apify actor to build a country dropdown with flags?"
- **Claude:** "What fields does the RestCountries Scraper return and how can I join them to my database?"
- **Perplexity:** "How do I automate country data collection with Apify's RestCountries Scraper?"
- **GitHub Copilot:** "Generate TypeScript types for the RestCountries Scraper output schema."

***

### ❓ Frequently Asked Questions

#### 🆓 Is this Actor free to use?

Free plan users get up to 10 records per run as a preview. Upgrade to a paid plan to unlock up to 1,000,000 records. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

#### 🔑 Do I need an API key for RestCountries?

No. The RestCountries v3.1 API is fully public and requires no authentication. This Actor handles all the API calls for you.

#### 🌍 How many countries does it cover?

The RestCountries API covers 250 countries and territories. This includes all UN member states plus territories and dependencies like Puerto Rico, Hong Kong, and French Guiana.

#### 🗺️ Can I filter by region?

Yes. Use the `region` input to filter by africa, americas, asia, europe, oceania, or antarctic. Set it to `all` (default) to fetch every country.

#### 🔍 How does the name search work?

The `search` field passes your input to the RestCountries `/name/{query}` endpoint, which performs a case-insensitive partial match. Searching "united" returns the United States, United Kingdom, United Arab Emirates, and United Republic of Tanzania. When `search` is set, it overrides the `region` filter.

#### 🖼️ Are the flag images usable in production?

Yes. The flag URLs point to `flagcdn.com`, a public CDN that serves high-quality PNG flags at 320px width. They can be embedded directly in any web or mobile application.

#### 💰 What format are currencies returned in?

Currencies are returned as an array of currency names (e.g. `["euro", "United States dollar"]`). Currency symbols and ISO codes are available in the raw API but normalized to names for readability.

#### 📞 How are calling codes formatted?

Calling codes are returned as E.164-style prefixes (e.g. `["+1"]` for the US, `["+49"]` for Germany). Countries with multiple suffixes (e.g. US territories) will have multiple entries in the array.

#### ⏱️ How fast does it run?

The entire 250-country dataset is collected in under 2 seconds. The API returns all data in a single HTTP call with no pagination.

#### 🔄 How often should I run it?

Country data is stable - capitals rarely change, populations update annually. For most use cases, a monthly or quarterly refresh is sufficient. For production applications seeding a database, a weekly run ensures currency names and territory data stay current.

#### 🧩 Can I export to Excel or CSV?

Yes. Once the run completes, click the **Export** button in the dataset view and choose CSV, Excel, JSON, or XML.

#### ❌ What happens if a country has no capital?

Some territories (like Antarctica) have no capital city. In those cases, the `capital` field returns `null` rather than an empty string, making it easy to handle in downstream processing.

***

### 🔌 Integrate with any app

Connect your country dataset to hundreds of tools instantly:

**Spreadsheets:** Google Sheets, Microsoft Excel, Airtable\
**Databases:** PostgreSQL, MySQL, MongoDB, Supabase, PlanetScale\
**BI tools:** Tableau, Power BI, Metabase, Looker, Grafana\
**Automation:** Make, Zapier, n8n, Pipedream, Activepieces\
**Storage:** AWS S3, Google Cloud Storage, Azure Blob, Dropbox\
**CRMs:** Salesforce, HubSpot, Pipedrive, Zoho\
**Communication:** Slack, Discord, Microsoft Teams, email via SendGrid\
**Dev tools:** REST API, Webhook, JavaScript SDK, Python SDK

***

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | 85,000+ global airports with ICAO, IATA codes, coordinates, and elevation |
| [Open-Meteo Weather Scraper](https://apify.com/parseforge/open-meteo-scraper) | Free historical and forecast weather data for any coordinates worldwide |
| [World Bank Data Scraper](https://apify.com/parseforge/world-bank-scraper) | Economic indicators, GDP, population data from the World Bank open API |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 50+ structured data actors covering aviation, finance, weather, government data, and more - all zero-auth, production-ready, and free to preview.

***

*This Actor is not affiliated with or endorsed by RestCountries or flagcdn.com. It uses only publicly available, unauthenticated API endpoints. Use responsibly and in accordance with the RestCountries terms of service.*

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `region` (type: `string`):

Filter countries by region. Select 'all' to scrape all 250 countries.

## `search` (type: `string`):

Optional. Search for a specific country by name (partial match supported, e.g. 'united'). Leave blank to use region filter.

## Actor input object example

```json
{
  "maxItems": 10,
  "region": "all"
}
```

# 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 = {
    "maxItems": 10,
    "region": "all"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/restcountries-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 = {
    "maxItems": 10,
    "region": "all",
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "REST Countries Scraper - Country Data and Flags",
        "description": "Scrape country data including names, capitals, populations, currencies, languages, and flags from the REST Countries API. Export structured country records.",
        "version": "0.1",
        "x-build-id": "Ycz6Q0DGyjUGpNJNO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~restcountries-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-restcountries-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~restcountries-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-restcountries-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~restcountries-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-restcountries-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": {
                    "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"
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "all",
                            "africa",
                            "americas",
                            "asia",
                            "europe",
                            "oceania",
                            "antarctic"
                        ],
                        "type": "string",
                        "description": "Filter countries by region. Select 'all' to scrape all 250 countries."
                    },
                    "search": {
                        "title": "Search Country Name",
                        "type": "string",
                        "description": "Optional. Search for a specific country by name (partial match supported, e.g. 'united'). Leave blank to use region filter."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
