# REST Countries Scraper (`crawlerbros/rest-countries-scraper`) Actor

Scrape REST Countries, the free public API for country metadata. Get name, capital, population, area, currencies, languages, borders, region/subregion, flags, timezones, calling codes, and more for all 250 ISO countries. HTTP-only, no auth, no proxy.

- **URL**: https://apify.com/crawlerbros/rest-countries-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 21 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## REST Countries Scraper

Scrape REST Countries — the free public API for country metadata. All 250 ISO countries, with name (common + official + native), capital, population, area, currencies, languages, borders, region/subregion, flags (emoji + PNG + SVG), timezones, calling codes, TLDs, lat/lng, and more. HTTP-only via the public `restcountries.com/v3.1` API. No auth, no proxy.

### What this actor does

- **Seven modes:** `all`, `byNames`, `byAlphaCodes`, `byRegion`, `bySubregion`, `byCurrency`, `byLanguage`
- **Filters:** min population, min area (km²), UN members only, independent states only
- **Auto-resolves alpha-2 / alpha-3 / numeric codes**
- **Empty fields are omitted**

### Output per country

- **Names:** `commonName`, `officialName`, `altSpellings[]`, `demonym`
- **ISO codes:** `cca2`, `cca3`, `ccn3`, `cioc`, `fifaCode`
- **Status:** `independent`, `unMember`, `status`, `landlocked`
- **Capital:** `capital[]`, `capitalPrimary`
- **Geography:** `region`, `subregion`, `continents[]`, `borders[]`, `latitude`, `longitude`
- **Demographics:** `population`, `areaKm2`
- **Symbols:** `flagEmoji` (🇩🇪), `flagPng`, `flagSvg`, `coatOfArmsPng`, `coatOfArmsSvg`
- **Currency / language:** `currencies[]` (code + name + symbol), `currencyCodes[]`, `languageCodes[]`, `languageNames[]`
- **Communications:** `timezones[]`, `callingCodes[]`, `tlds[]`
- **Maps:** `googleMapsUrl`, `openStreetMapsUrl`
- `recordType: "country"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `all` | One of seven modes |
| `names` | array | – | Country names (mode=byNames) |
| `alphaCodes` | array | – | Alpha-2/3 codes (mode=byAlphaCodes) |
| `region` | string | – | Continental region |
| `subregion` | string | – | Subregion (e.g. `Western Europe`) |
| `currency` | string | – | ISO 4217 (mode=byCurrency) |
| `language` | string | – | Language name or ISO code |
| `minPopulation` | int | – | Drop countries below this |
| `minArea` | int | – | Drop countries below this km² |
| `unMembersOnly` | bool | `false` | – |
| `independentOnly` | bool | `false` | Excludes territories |
| `maxItems` | int | `250` | Hard cap (1–500) |

#### Example: all UN member states with population > 10M

```json
{
  "mode": "all",
  "minPopulation": 10000000,
  "unMembersOnly": true
}
````

#### Example: lookup specific countries

```json
{
  "mode": "byAlphaCodes",
  "alphaCodes": ["DE", "FR", "ES", "IT", "GB", "PT"]
}
```

#### Example: all Eurozone countries

```json
{
  "mode": "byCurrency",
  "currency": "EUR"
}
```

#### Example: all Spanish-speaking countries

```json
{
  "mode": "byLanguage",
  "language": "spanish"
}
```

### Use cases

- **Geographic dropdowns** — populate forms with all countries, sorted by region
- **Lookup tables** — alpha-2 ↔ alpha-3 ↔ numeric ISO mappings
- **Phone-number formatting** — `callingCodes[]` for international dialing
- **Flag UI** — `flagEmoji` for inline display, `flagSvg` for high-DPI
- **Currency converter** — group countries by currency for FX UIs
- **i18n** — group countries by official language

### FAQ

**Is the REST Countries API free?**  Yes. Self-hosted, no auth, no rate limits beyond reasonable use.

**What's the difference between `cca2` / `cca3` / `ccn3` / `cioc`?**  ISO 3166-1 alpha-2 (`DE`), alpha-3 (`DEU`), numeric (`276`), and IOC (`GER`) codes respectively.

**Why does `mode=all` require many requests of fields?**  REST Countries v3.1+ requires explicit `fields=` parameter for `/all` to keep payloads small. The actor sends a comprehensive list — every field documented above.

**How many countries are there?**  250 entries (includes territories, dependencies, Antarctic). For sovereign UN states only, set `unMembersOnly: true` (193 entries).

**What's `cioc`?**  International Olympic Committee code. Only set for countries that compete in the Olympics.

**Why is `latitude` / `longitude` sometimes missing?**  REST Countries returns `latlng: ["bad", "data"]` for a few entries. The actor handles this gracefully.

**How fresh is the data?**  Updated periodically (manual edits by maintainers). For real-time political changes, supplement with a different source.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

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

Country names to look up (e.g. `Germany`, `United States`, `India`). Matched fully via fullText param.

## `alphaCodes` (type: `array`):

ISO 3166-1 alpha-2 (e.g. `DE`, `US`) or alpha-3 (e.g. `DEU`, `USA`) codes.

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

Continental region.

## `subregion` (type: `string`):

Subregion (e.g. `Western Europe`, `Southern Asia`, `Caribbean`).

## `currency` (type: `string`):

ISO 4217 currency code (e.g. `EUR`, `USD`, `JPY`).

## `language` (type: `string`):

Language name or ISO 639-1/2/3 code (e.g. `english`, `eng`, `spa`).

## `capital` (type: `string`):

Capital city name (e.g. `Berlin`, `Tokyo`, `Brasilia`).

## `translation` (type: `string`):

Country name in another language (e.g. `Deutschland`, `Allemagne`, `Alemania`).

## `demonym` (type: `string`):

Demonym for residents (e.g. `german`, `french`, `american`).

## `minPopulation` (type: `integer`):

Drop countries below this population.

## `minArea` (type: `integer`):

Drop countries with land area below this (in km²).

## `unMembersOnly` (type: `boolean`):

Only emit UN member states.

## `independentOnly` (type: `boolean`):

Only emit independent (sovereign) states; excludes territories / dependencies.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "all",
  "names": [],
  "alphaCodes": [],
  "unMembersOnly": false,
  "independentOnly": false,
  "maxItems": 250
}
```

# Actor output Schema

## `countries` (type: `string`):

Dataset containing all scraped country records.

# 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 = {
    "mode": "all",
    "names": [],
    "alphaCodes": [],
    "unMembersOnly": false,
    "independentOnly": false,
    "maxItems": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/rest-countries-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 = {
    "mode": "all",
    "names": [],
    "alphaCodes": [],
    "unMembersOnly": False,
    "independentOnly": False,
    "maxItems": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/rest-countries-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 '{
  "mode": "all",
  "names": [],
  "alphaCodes": [],
  "unMembersOnly": false,
  "independentOnly": false,
  "maxItems": 250
}' |
apify call crawlerbros/rest-countries-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "REST Countries Scraper",
        "description": "Scrape REST Countries, the free public API for country metadata. Get name, capital, population, area, currencies, languages, borders, region/subregion, flags, timezones, calling codes, and more for all 250 ISO countries. HTTP-only, no auth, no proxy.",
        "version": "1.0",
        "x-build-id": "C6Lu9JUP1OdKSLEBG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~rest-countries-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-rest-countries-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/crawlerbros~rest-countries-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-rest-countries-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/crawlerbros~rest-countries-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-rest-countries-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "all",
                            "byNames",
                            "byAlphaCodes",
                            "byRegion",
                            "bySubregion",
                            "byCurrency",
                            "byLanguage",
                            "byCapital",
                            "byTranslation",
                            "byDemonym"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "all"
                    },
                    "names": {
                        "title": "Country names (mode=byNames)",
                        "type": "array",
                        "description": "Country names to look up (e.g. `Germany`, `United States`, `India`). Matched fully via fullText param.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "alphaCodes": {
                        "title": "Alpha codes (mode=byAlphaCodes)",
                        "type": "array",
                        "description": "ISO 3166-1 alpha-2 (e.g. `DE`, `US`) or alpha-3 (e.g. `DEU`, `USA`) codes.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "region": {
                        "title": "Region (mode=byRegion)",
                        "enum": [
                            "Africa",
                            "Americas",
                            "Asia",
                            "Europe",
                            "Oceania",
                            "Antarctic"
                        ],
                        "type": "string",
                        "description": "Continental region."
                    },
                    "subregion": {
                        "title": "Subregion (mode=bySubregion)",
                        "type": "string",
                        "description": "Subregion (e.g. `Western Europe`, `Southern Asia`, `Caribbean`)."
                    },
                    "currency": {
                        "title": "Currency code (mode=byCurrency)",
                        "type": "string",
                        "description": "ISO 4217 currency code (e.g. `EUR`, `USD`, `JPY`)."
                    },
                    "language": {
                        "title": "Language (mode=byLanguage)",
                        "type": "string",
                        "description": "Language name or ISO 639-1/2/3 code (e.g. `english`, `eng`, `spa`)."
                    },
                    "capital": {
                        "title": "Capital (mode=byCapital)",
                        "type": "string",
                        "description": "Capital city name (e.g. `Berlin`, `Tokyo`, `Brasilia`)."
                    },
                    "translation": {
                        "title": "Translation (mode=byTranslation)",
                        "type": "string",
                        "description": "Country name in another language (e.g. `Deutschland`, `Allemagne`, `Alemania`)."
                    },
                    "demonym": {
                        "title": "Demonym (mode=byDemonym)",
                        "type": "string",
                        "description": "Demonym for residents (e.g. `german`, `french`, `american`)."
                    },
                    "minPopulation": {
                        "title": "Min population",
                        "minimum": 0,
                        "maximum": 10000000000,
                        "type": "integer",
                        "description": "Drop countries below this population."
                    },
                    "minArea": {
                        "title": "Min area (km²)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop countries with land area below this (in km²)."
                    },
                    "unMembersOnly": {
                        "title": "UN members only",
                        "type": "boolean",
                        "description": "Only emit UN member states.",
                        "default": false
                    },
                    "independentOnly": {
                        "title": "Independent countries only",
                        "type": "boolean",
                        "description": "Only emit independent (sovereign) states; excludes territories / dependencies.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
