# Country Flags Scraper (250+ Countries, 8 Sizes) (`parseforge/flagcdn-country-flags-scraper`) Actor

Fetch country flag image URLs in multiple sizes (16, 24, 32, 48, 64, 80, 96, 128, 160, 192, 256 pixels) plus SVG vector format. Get ISO 3166-1 alpha-2 codes and country names. Export to JSON, CSV, or Excel for apps, dashboards, ecommerce localization, and i18n design pipelines.

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

## Pricing

from $9.00 / 1,000 result items

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)

## 🏳️ Country Flags CDN Scraper

> 🚀 **Export CC-BY country flag URLs in seconds.** Pull **250+ country flags** at **8 resolutions** (w20 to w2560) with localized country names in **9 languages**. CDN-hosted PNGs, no rate limits.

> 🕒 **Last updated:** 2026-05-23 · **📊 7 fields** per record · **🏳️ 250+ countries** · **🖼️ 8 resolutions** · **🌍 9 languages**

The **Country Flags CDN Scraper** queries the public FlagCDN catalog, the most widely used CC-BY licensed flag CDN online. It returns **7 structured fields per record**, including the preview URL, ISO 3166-1 alpha-2 country code, localized country name, language code, the full flag URL set at the chosen resolutions, and the scrape timestamp.

The catalog covers **250+ countries and territories** including all UN member states, dependencies, observer states (e.g. EU, XK), and select non-sovereign codes (e.g. UN). Eight raster resolutions (w20, w40, w80, w160, w320, w640, w1280, w2560) ship per country, plus localized country names in English, Spanish, French, German, Italian, Portuguese, Chinese, Japanese, and Korean. Downloadable as CSV, Excel, JSON, or XML.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Travel and booking platforms, edtech, dashboards, language-learning apps, news outlets, civic-tech, design systems, internationalized SaaS | Country picker dropdowns, dashboard country tiles, language-learning flashcards, travel-app country chips, news topic icons, internationalized email templates |

---

### 📋 What the Country Flags CDN Scraper does

Two lookup workflows in a single run:

- 🖼️ **Flag URLs mode.** Per-country PNG URLs at every resolution you request, plus an ISO code and localized country name.
- 🌐 **Codes mode.** Compact reference: just the alpha-2 code and localized country name.
- 🌍 **Localization.** Country names are returned in your chosen language (en, es, fr, de, it, pt, zh, ja, ko).
- 🎯 **Country filter.** Optional alpha-2 list to scope the run to a subset of countries.
- 📐 **Resolution picker.** Choose any subset of the 8 supported widths.

Each record bundles the preview URL (defaults to w320), country code, localized name, language, the full URL set keyed by width, and the scrape timestamp.

> 💡 **Why it matters:** every country picker, every dashboard tile, every language flashcard app needs flag assets. Self-hosting means paying for storage and bandwidth, plus tracking flag-design updates. This Actor delivers a CC-BY URL set you can plug directly into any UI, with zero hosting cost.

---

### 🎬 Full Demo

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

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>mode</td><td>string</td><td>"flagUrls"</td><td>One of flagUrls (full URL set) or codes (compact reference).</td></tr>
<tr><td>language</td><td>string</td><td>"en"</td><td>Localization for the country name field. 9 languages supported.</td></tr>
<tr><td>countries</td><td>array</td><td>[]</td><td>Optional ISO 3166-1 alpha-2 filter. Empty returns all 250+.</td></tr>
<tr><td>resolutions</td><td>array</td><td>["w80","w160","w320","w640"]</td><td>PNG widths to include. Pick any subset of the 8 supported.</td></tr>
</tbody>
</table>

**Example: full flag set for the G7 in English.**

```json
{
    "maxItems": 7,
    "mode": "flagUrls",
    "language": "en",
    "countries": ["US", "GB", "DE", "FR", "IT", "CA", "JP"],
    "resolutions": ["w80", "w160", "w320", "w640", "w1280"]
}
````

**Example: every country with Spanish names, codes only.**

```json
{
    "maxItems": 300,
    "mode": "codes",
    "language": "es"
}
```

> ⚠️ **Good to Know:** flags are CC-BY licensed PNGs hosted on a CDN. Attribution to the source CDN is appreciated and detailed on their site. Smaller resolutions (w20-w160) are ideal for inline UI badges; w640+ for hero images and presentations.

***

### 📊 Output

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

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `flagPreviewUrl` | string | `"https://flagcdn.com/w320/de.png"` |
| 🆔 `countryCode` | string | `"DE"` |
| 🏳️ `countryName` | string | `"Germany"` |
| 🌍 `language` | string | `"en"` |
| 📐 `flagUrls` | object | `{ "w80": "...", "w160": "...", "w320": "..." }` |
| 🔧 `mode` | string | `"flagUrls"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-23T10:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🇩🇪 Germany at four resolutions</strong></summary>

```json
{
    "flagPreviewUrl": "https://flagcdn.com/w320/de.png",
    "countryCode": "DE",
    "countryName": "Germany",
    "language": "en",
    "flagUrls": {
        "w80": "https://flagcdn.com/w80/de.png",
        "w160": "https://flagcdn.com/w160/de.png",
        "w320": "https://flagcdn.com/w320/de.png",
        "w640": "https://flagcdn.com/w640/de.png"
    },
    "mode": "flagUrls",
    "scrapedAt": "2026-05-23T10:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🇯🇵 Japan in Japanese</strong></summary>

```json
{
    "flagPreviewUrl": "https://flagcdn.com/w320/jp.png",
    "countryCode": "JP",
    "countryName": "日本",
    "language": "ja",
    "flagUrls": {
        "w80": "https://flagcdn.com/w80/jp.png",
        "w160": "https://flagcdn.com/w160/jp.png",
        "w320": "https://flagcdn.com/w320/jp.png",
        "w640": "https://flagcdn.com/w640/jp.png"
    },
    "mode": "flagUrls",
    "scrapedAt": "2026-05-23T10:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🇪🇸 Codes mode: Spanish names only</strong></summary>

```json
{
    "countryCode": "ES",
    "countryName": "España",
    "language": "es",
    "mode": "codes",
    "scrapedAt": "2026-05-23T10:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏳️ | **250+ countries.** UN members, dependencies, observer states, EU and UN codes. |
| 🖼️ | **8 resolutions.** From w20 favicon-size to w2560 hero-image-size in one record. |
| 🌍 | **9 languages.** Country names localized to English, Spanish, French, German, Italian, Portuguese, Chinese, Japanese, Korean. |
| 📦 | **CDN-hosted.** No rate limits, no hotlink-blocking, ready to drop into any frontend. |
| ⚖️ | **CC-BY licensed.** Commercial reuse permitted with attribution to the source. |
| 🎯 | **Country filter.** Pass an alpha-2 list to scope to your supported markets. |
| 🚫 | **No authentication.** Works against the public CDN catalog. No login or API key needed. |

> 📊 Flags are the universal visual shorthand for countries. Good flag UX makes country pickers, dashboards, and language tools instantly readable.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Setup |
|---|---|---|---|---|
| **⭐ Country Flags CDN Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **250+ countries, 8 sizes** | **Live per run** | ⚡ 2 min |
| Self-host flag PNGs | Storage + bandwidth | Build it yourself | Manual | 🛠️ Hours |
| Emoji flags | Free | Limited, font-dependent | Static | ⏳ Inconsistent across OS |
| Commercial icon packs | $50+ | Stylized | Static | 💸 Per-developer license |

Pick this Actor when you want CDN-hosted CC-BY flags ready for production without hosting your own assets.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Country Flags CDN Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a mode, a language, an optional country filter, and the resolutions you need. Set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### ✈️ Travel & Booking

- Country picker dropdowns with flag icons
- Destination tiles on home pages
- Booking confirmation emails with country branding
- Localized landing pages per market

</td>
<td width="50%" valign="top">

#### 📚 Edtech & Language Learning

- Flag flashcards for geography lessons
- Language-learning country chips
- Cultural studies course materials
- Quiz apps and trivia games

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Dashboards & Analytics

- Country tiles in KPI dashboards
- Geographic distribution charts
- User-base maps and visualizations
- Internationalized admin panels

</td>
<td width="50%" valign="top">

#### 🌐 SaaS & E-commerce

- Localized billing currency badges
- International shipping selectors
- Multi-language settings UI
- Country-specific feature toggles

</td>
</tr>
</table>

***

### 🔌 Automating Country Flags CDN Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. A quarterly refresh keeps your flag catalog in sync with any design updates.

***

### 🌟 Beyond business use cases

Country flags are foundational visual data. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Geography and political-science coursework
- International relations visualizations
- Open-data exercises on country reference sets
- Multilingual UX studies

</td>
<td width="50%">

#### 🎨 Personal and creative

- Travel scrapbooks and photo journals
- Personal blogs with country tagging
- Custom map prints and infographics
- Hobbyist geography quiz apps

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Humanitarian aid dashboards
- Election monitoring visualizations
- International advocacy campaigns
- Refugee resettlement program tooling

</td>
<td width="50%">

#### 🧪 Experimentation

- Train image-recognition models on flags
- Prototype language-learning agents
- Build country-aware browser extensions
- Test internationalized email templates

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Country%20Flags%20CDN%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Country%20Flags%20CDN%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Country%20Flags%20CDN%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Country%20Flags%20CDN%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a mode (`flagUrls` or `codes`), choose a language and optional country filter, select the resolutions you need, click Start, and the Actor emits one clean structured record per country.

#### 📏 How accurate is the data?

ISO 3166-1 alpha-2 codes are the global standard. Country names are localized translations maintained by the source CDN. For unrecognized regions or contested territories, the catalog follows ISO conventions.

#### 🔁 How often is the dataset refreshed?

The catalog updates whenever country flag designs change, which is rare (a handful of times per decade). Every run pulls the live URL set so any new entries flow through.

#### 🌍 How many countries are supported?

250+ entries, including all UN member states, dependent territories, observer states (EU, XK), and select non-sovereign codes (UN).

#### 🖼️ What resolutions are available?

Eight PNG widths: w20, w40, w80, w160, w320, w640, w1280, w2560. Pick any subset per run.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval. A quarterly cron keeps your flag catalog fresh.

#### ⚖️ Is this data legal to use?

Flags are public symbols and the PNG renditions are CC-BY licensed. Commercial use is permitted with attribution to the CDN provider. Check the source for the exact license text.

#### 💼 Can I use this data commercially?

Yes, CC-BY licensed for commercial reuse with attribution.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and unlocks scheduling, higher concurrency, and full-catalog pulls of all 250+ countries.

#### 🌏 Does it cover dependencies and territories?

Yes. The catalog includes dependencies (e.g. PR, GU, GL), observer states (EU, XK), and special codes (UN). The `countries` filter accepts any alpha-2 code in the catalog.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Country Flags CDN Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe flag URL sets into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to refresh your design-system flag asset catalog on every run.

***

### 🔗 Recommended Actors

- [**🌐 Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap
- [**🛬 OurAirports Global Airport Database Scraper**](https://apify.com/parseforge/ourairports-scraper) - Global aviation reference dataset
- [**💱 Frankfurter FX Rates Scraper**](https://apify.com/parseforge/frankfurter-fx-rates-scraper) - ECB-derived foreign-exchange rates
- [**🏦 IBAN Bank Codes Scraper**](https://apify.com/parseforge/iban-com-bank-codes-scraper) - IBAN structures and ISO country codes
- [**📈 Indexmundi Scraper**](https://apify.com/parseforge/indexmundi-scraper) - Global demographic and economic indicators

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by FlagCDN or any flag-asset provider. All trademarks mentioned are the property of their respective owners. Only publicly available CC-BY licensed flag assets are referenced.

# Actor input Schema

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

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

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

Codes only (compact name + code reference) or flagUrls (full PNG URL set at the requested resolutions).

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

Localization for the country name field.

## `countries` (type: `array`):

Optional ISO 3166-1 alpha-2 filter. Empty = return all available.

## `resolutions` (type: `array`):

PNG widths to include in each record (flagUrls mode only). Pick any subset.

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "flagUrls",
  "language": "en",
  "resolutions": [
    "w80",
    "w160",
    "w320",
    "w640"
  ]
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "maxItems": 10,
    "mode": "flagUrls",
    "language": "en",
    "resolutions": [
        "w80",
        "w160",
        "w320",
        "w640"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/flagcdn-country-flags-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,
    "mode": "flagUrls",
    "language": "en",
    "resolutions": [
        "w80",
        "w160",
        "w320",
        "w640",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/flagcdn-country-flags-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,
  "mode": "flagUrls",
  "language": "en",
  "resolutions": [
    "w80",
    "w160",
    "w320",
    "w640"
  ]
}' |
apify call parseforge/flagcdn-country-flags-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Country Flags Scraper (250+ Countries, 8 Sizes)",
        "description": "Fetch country flag image URLs in multiple sizes (16, 24, 32, 48, 64, 80, 96, 128, 160, 192, 256 pixels) plus SVG vector format. Get ISO 3166-1 alpha-2 codes and country names. Export to JSON, CSV, or Excel for apps, dashboards, ecommerce localization, and i18n design pipelines.",
        "version": "1.0",
        "x-build-id": "mdYJiGca1tFB5rgds"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~flagcdn-country-flags-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-flagcdn-country-flags-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~flagcdn-country-flags-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-flagcdn-country-flags-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~flagcdn-country-flags-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-flagcdn-country-flags-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"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "flagUrls",
                            "codes"
                        ],
                        "type": "string",
                        "description": "Codes only (compact name + code reference) or flagUrls (full PNG URL set at the requested resolutions)."
                    },
                    "language": {
                        "title": "Country Name Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "zh",
                            "ja",
                            "ko"
                        ],
                        "type": "string",
                        "description": "Localization for the country name field."
                    },
                    "countries": {
                        "title": "Countries (alpha-2 filter)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional ISO 3166-1 alpha-2 filter. Empty = return all available.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AD",
                                "AE",
                                "AF",
                                "AG",
                                "AI",
                                "AL",
                                "AM",
                                "AO",
                                "AQ",
                                "AR",
                                "AS",
                                "AT",
                                "AU",
                                "AW",
                                "AX",
                                "AZ",
                                "BA",
                                "BB",
                                "BD",
                                "BE",
                                "BF",
                                "BG",
                                "BH",
                                "BI",
                                "BJ",
                                "BL",
                                "BM",
                                "BN",
                                "BO",
                                "BQ",
                                "BR",
                                "BS",
                                "BT",
                                "BV",
                                "BW",
                                "BY",
                                "BZ",
                                "CA",
                                "CC",
                                "CD",
                                "CF",
                                "CG",
                                "CH",
                                "CI",
                                "CK",
                                "CL",
                                "CM",
                                "CN",
                                "CO",
                                "CR",
                                "CU",
                                "CV",
                                "CW",
                                "CX",
                                "CY",
                                "CZ",
                                "DE",
                                "DJ",
                                "DK",
                                "DM",
                                "DO",
                                "DZ",
                                "EC",
                                "EE",
                                "EG",
                                "EH",
                                "ER",
                                "ES",
                                "ET",
                                "EU",
                                "FI",
                                "FJ",
                                "FK",
                                "FM",
                                "FO",
                                "FR",
                                "GA",
                                "GB",
                                "GD",
                                "GE",
                                "GF",
                                "GG",
                                "GH",
                                "GI",
                                "GL",
                                "GM",
                                "GN",
                                "GP",
                                "GQ",
                                "GR",
                                "GS",
                                "GT",
                                "GU",
                                "GW",
                                "GY",
                                "HK",
                                "HM",
                                "HN",
                                "HR",
                                "HT",
                                "HU",
                                "ID",
                                "IE",
                                "IL",
                                "IM",
                                "IN",
                                "IO",
                                "IQ",
                                "IR",
                                "IS",
                                "IT",
                                "JE",
                                "JM",
                                "JO",
                                "JP",
                                "KE",
                                "KG",
                                "KH",
                                "KI",
                                "KM",
                                "KN",
                                "KP",
                                "KR",
                                "KW",
                                "KY",
                                "KZ",
                                "LA",
                                "LB",
                                "LC",
                                "LI",
                                "LK",
                                "LR",
                                "LS",
                                "LT",
                                "LU",
                                "LV",
                                "LY",
                                "MA",
                                "MC",
                                "MD",
                                "ME",
                                "MF",
                                "MG",
                                "MH",
                                "MK",
                                "ML",
                                "MM",
                                "MN",
                                "MO",
                                "MP",
                                "MQ",
                                "MR",
                                "MS",
                                "MT",
                                "MU",
                                "MV",
                                "MW",
                                "MX",
                                "MY",
                                "MZ",
                                "NA",
                                "NC",
                                "NE",
                                "NF",
                                "NG",
                                "NI",
                                "NL",
                                "NO",
                                "NP",
                                "NR",
                                "NU",
                                "NZ",
                                "OM",
                                "PA",
                                "PE",
                                "PF",
                                "PG",
                                "PH",
                                "PK",
                                "PL",
                                "PM",
                                "PN",
                                "PR",
                                "PS",
                                "PT",
                                "PW",
                                "PY",
                                "QA",
                                "RE",
                                "RO",
                                "RS",
                                "RU",
                                "RW",
                                "SA",
                                "SB",
                                "SC",
                                "SD",
                                "SE",
                                "SG",
                                "SH",
                                "SI",
                                "SJ",
                                "SK",
                                "SL",
                                "SM",
                                "SN",
                                "SO",
                                "SR",
                                "SS",
                                "ST",
                                "SV",
                                "SX",
                                "SY",
                                "SZ",
                                "TC",
                                "TD",
                                "TF",
                                "TG",
                                "TH",
                                "TJ",
                                "TK",
                                "TL",
                                "TM",
                                "TN",
                                "TO",
                                "TR",
                                "TT",
                                "TV",
                                "TW",
                                "TZ",
                                "UA",
                                "UG",
                                "UM",
                                "UN",
                                "US",
                                "UY",
                                "UZ",
                                "VA",
                                "VC",
                                "VE",
                                "VG",
                                "VI",
                                "VN",
                                "VU",
                                "WF",
                                "WS",
                                "XK",
                                "YE",
                                "YT",
                                "ZA",
                                "ZM",
                                "ZW"
                            ]
                        }
                    },
                    "resolutions": {
                        "title": "Resolutions",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "PNG widths to include in each record (flagUrls mode only). Pick any subset.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "w20",
                                "w40",
                                "w80",
                                "w160",
                                "w320",
                                "w640",
                                "w1280",
                                "w2560"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
