# TradingEconomics Scraper (`automation-lab/tradingeconomics-scraper`) Actor

Extract economic indicators from TradingEconomics.com. Get GDP, inflation, unemployment, interest rates, and 20M+ indicators across 196 countries. No API key needed.

- **URL**: https://apify.com/automation-lab/tradingeconomics-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## TradingEconomics Scraper

Extract economic indicators from [TradingEconomics.com](https://tradingeconomics.com) — the world's largest economic data platform covering 20 million indicators across 196 countries. No API key required. No subscription needed. Get GDP, inflation, unemployment, interest rates, and hundreds more indicators in seconds.

### 🌍 What does TradingEconomics Scraper do?

**TradingEconomics Scraper** lets you extract structured economic indicator data from TradingEconomics.com without paying their $25–$500/month API subscription. The scraper handles all three main page types:

- **Country indicators page** (`/united-states/indicators`) — all indicators for one or more countries, organized by category (GDP, Labour, Prices, Money, Trade, Government, Business, Consumer, Housing, Energy, Health)
- **Country list for indicator** (`/country-list/gdp`) — a specific indicator (e.g., GDP or inflation rate) across all available countries
- **Direct URL** — any TradingEconomics URL of either type above

Every scraped item includes: country, indicator name, latest value, previous value, highest recorded, lowest recorded, unit, reference period, and a direct URL to the indicator page.

### 👤 Who is it for?

**Economists and researchers** tracking macroeconomic trends across multiple countries
- 🔹 Compare GDP growth rates across G20 nations for a quarterly report
- 🔹 Build a database of inflation data spanning 50 countries over time
- 🔹 Cross-reference unemployment data with consumer confidence metrics

**Financial analysts and traders** monitoring economic calendars
- 🔹 Pull the latest interest rate decisions across all central banks
- 🔹 Monitor inflation and CPI data to inform trading decisions
- 🔹 Track government debt-to-GDP ratios for sovereign risk analysis

**Data scientists and developers** building economic dashboards
- 🔹 Feed economic indicator data into Pandas for analysis
- 🔹 Power a Bloomberg-style dashboard with live macroeconomic data
- 🔹 Automate weekly downloads of economic indicator snapshots

**Business intelligence teams** in multinational corporations
- 🔹 Monitor economic conditions in countries where the company operates
- 🔹 Compare cost-of-living indicators across office locations
- 🔹 Track trade balance and exchange rate data for procurement planning

### ✅ Why use TradingEconomics Scraper?

- 📊 **20M+ indicators across 196 countries** — the most comprehensive free economic dataset available
- 💸 **No API key required** — TradingEconomics charges $25–$500/month for API access; this scraper gets the same data from the public website
- ⚡ **Pure HTTP scraping** — no browser overhead. Requests complete in under 1 second per page
- 🗂️ **Organized by category** — filter by GDP, Labour, Prices, Money, Trade, Government, Business, Consumer, Housing, Energy, or Health
- 🔄 **Schedule regular runs** — set up daily or weekly snapshots to track trends over time
- 📤 **Export to JSON, CSV, or Excel** — one click from the Apify Console
- 🔗 **Direct URL support** — paste any TradingEconomics URL for ad-hoc lookups

### 📦 What data can you extract?

Every output item contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `country` | string | Country name (e.g., "United States") |
| `countrySlug` | string | URL slug (e.g., "united-states") |
| `indicator` | string | Indicator name (e.g., "GDP Growth Rate") |
| `indicatorSlug` | string | URL slug (e.g., "gdp-growth-rate") |
| `value` | number | Latest reported value |
| `previous` | number | Previous period value |
| `highest` | number | All-time highest recorded value |
| `lowest` | number | All-time lowest recorded value |
| `unit` | string | Unit of measurement (e.g., "percent", "USD Billion") |
| `reference` | string | Reference period (e.g., "Mar/26", "Dec/24") |
| `category` | string | Indicator category (e.g., "gdp", "labour", "prices") |
| `url` | string | Direct link to the indicator page |
| `scrapedAt` | string | ISO 8601 timestamp of when the data was extracted |

**Available indicator categories:**

| Category | Examples |
|----------|---------|
| 📈 Overview | GDP, Unemployment, Inflation, Interest Rate, Stock Market |
| 💰 GDP | GDP Growth Rate, GDP Per Capita, GDP from Manufacturing |
| 👷 Labour | Unemployment Rate, Employment Change, Wage Growth, Labor Force |
| 💵 Prices | Inflation Rate, CPI, PPI, Core Inflation |
| 🏦 Money | Interest Rate, Money Supply, Central Bank Balance Sheet |
| 🌐 Trade | Balance of Trade, Exports, Imports, Current Account |
| 🏛️ Government | Government Debt to GDP, Budget, Tax Rate |
| 🏭 Business | Business Confidence, PMI, Industrial Production |
| 🛒 Consumer | Consumer Confidence, Retail Sales, Consumer Spending |
| 🏠 Housing | Housing Starts, Building Permits, Home Prices |
| ⚡ Energy | Crude Oil, Natural Gas, Coal Production |
| 🏥 Health | Hospital Beds, Healthcare Spending, Life Expectancy |

### 💵 How much does it cost to scrape TradingEconomics data?

This Actor uses **pay-per-event** pricing — you pay only for what you scrape. No monthly subscription. All platform compute costs are **included**.

| | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) |
|---|---|---|---|---|
| **Per indicator** | $0.00115 | $0.001 | $0.00078 | $0.0006 |
| **100 indicators** | $0.115 | $0.10 | $0.078 | $0.06 |
| **1,000 indicators** | $1.15 | $1.00 | $0.78 | $0.60 |

Higher-tier plans (Platinum, Diamond) get additional volume discounts.

**Real-world cost examples:**

| Task | Indicators | Duration | Cost (Free tier) |
|------|-----------|---------|-----------------|
| US overview indicators | ~20 | ~2s | ~$0.023 |
| All US categories | ~408 | ~3s | ~$0.47 |
| GDP across all countries | ~200 | ~2s | ~$0.23 |
| 5 countries, overview only | ~100 | ~8s | ~$0.115 |

**Free plan estimate:** Apify gives $5 in free credits. At Free tier pricing, you can scrape approximately **4,350 indicators** before spending your first dollar.

**vs. TradingEconomics official API:** Their API costs $25–$500/month. This scraper extracts the same public data at a fraction of the cost for occasional or scheduled use.

### 🚀 How to scrape TradingEconomics data

1. [Open TradingEconomics Scraper on Apify Store](https://apify.com/automation-lab/tradingeconomics-scraper)
2. Click **Try for free**
3. Select your scrape mode:
   - **Country indicators** — enter country slugs like `united-states`, `germany`, `china`
   - **Country list for indicator** — enter an indicator slug like `gdp`, `inflation-rate`
   - **Direct URL** — paste any TradingEconomics URL
4. Click **Save & Run**
5. Download results as JSON, CSV, or Excel when the run completes

**Example inputs for different scenarios:**

Scrape key economic indicators for the US and Germany:
```json
{
    "mode": "country-indicators",
    "countries": ["united-states", "germany"],
    "categories": ["overview"],
    "maxIndicators": 0
}
````

Compare GDP across all countries:

```json
{
    "mode": "country-list",
    "indicator": "gdp",
    "maxIndicators": 0
}
```

Scrape a specific TradingEconomics page:

```json
{
    "mode": "direct-url",
    "directUrl": "https://tradingeconomics.com/country-list/inflation-rate",
    "maxIndicators": 0
}
```

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `country-indicators` | Scraping mode: `country-indicators`, `country-list`, or `direct-url` |
| `countries` | array | `["united-states"]` | List of country slugs. Used in `country-indicators` mode |
| `categories` | array | `[]` (all) | Indicator categories to filter. Empty = all categories |
| `indicator` | string | `gdp` | Indicator slug for `country-list` mode |
| `directUrl` | string | — | Full URL for `direct-url` mode |
| `maxIndicators` | integer | `0` (no limit) | Max results to return. 0 = no limit |
| `proxy` | object | datacenter | Proxy configuration |

**Country slugs** match TradingEconomics URLs: `united-states`, `germany`, `china`, `japan`, `united-kingdom`, `france`, `india`, `brazil`, `canada`, `australia`, etc.

**Indicator category options:** `overview`, `gdp`, `labour`, `prices`, `money`, `trade`, `government`, `business`, `consumer`, `housing`, `energy`, `health`

**Common indicator slugs:** `gdp`, `gdp-growth-rate`, `unemployment-rate`, `inflation-rate`, `interest-rate`, `balance-of-trade`, `current-account`, `government-debt-to-gdp`, `business-confidence`, `consumer-confidence`, `industrial-production`

### 📊 Output examples

**Country indicators mode:**

```json
{
    "country": "United States",
    "countrySlug": "united-states",
    "indicator": "Inflation Rate",
    "indicatorSlug": "inflation-rate",
    "value": 2.4,
    "previous": 2.4,
    "highest": 23.7,
    "lowest": -15.8,
    "unit": "percent",
    "reference": "Feb/26",
    "category": "prices",
    "url": "https://tradingeconomics.com/united-states/inflation-rate",
    "scrapedAt": "2026-04-06T10:00:00.000Z"
}
```

**Country list mode:**

```json
{
    "country": "Germany",
    "countrySlug": "germany",
    "indicator": "GDP",
    "indicatorSlug": "gdp",
    "value": 4659.93,
    "previous": 4456.49,
    "highest": null,
    "lowest": null,
    "unit": "USD Billion",
    "reference": "Dec/24",
    "category": "country-list",
    "url": "https://tradingeconomics.com/germany/gdp",
    "scrapedAt": "2026-04-06T10:00:00.000Z"
}
```

### 💡 Tips for best results

- 🗂️ **Use categories to filter** — if you only need GDP data, set `categories: ["gdp"]` instead of scraping all 408+ indicators per country
- 🔄 **Schedule for monitoring** — set up a daily or weekly run to track economic trends over time. The data updates whenever TradingEconomics publishes new releases
- 📦 **Country list mode is faster** — use `country-list` to compare one indicator across many countries (single page load) vs. `country-indicators` which loads one page per country
- 🌍 **Batch multiple countries** — pass several countries in one run to minimize overhead: `["united-states", "germany", "china", "japan", "uk"]`
- 📊 **Start small for testing** — set `maxIndicators: 50` when testing to keep runs fast and cheap, then remove the limit for production runs

### 🔌 Integrations

**TradingEconomics Scraper → Google Sheets**
Use Apify's [Google Sheets integration](https://apify.com/apify/google-sheets-import-export) to automatically push economic data into a spreadsheet. Schedule weekly runs to build a time-series database of GDP, inflation, and unemployment across your target countries.

**TradingEconomics Scraper → Slack/Discord alerts**
Combine with Apify webhooks to send alerts when economic indicators cross thresholds. Trigger a Slack notification when the US unemployment rate changes month-over-month.

**TradingEconomics Scraper → Make / Zapier**
Use Apify's Make or Zapier integration to feed economic data into your existing workflows — route to Airtable, Notion, Power BI, or any app your team uses for reporting.

**Scheduled monitoring**
Use Apify's built-in scheduler to run the scraper daily or weekly. Compare each run's dataset to the previous one to detect new data releases and flag significant changes.

**Webhook-driven processing**
Configure an Apify webhook to POST dataset URLs to your backend when a run completes. Your service can then pull the data and update dashboards in real time.

### 🔧 API usage

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/tradingeconomics-scraper').call({
    mode: 'country-list',
    indicator: 'gdp',
    maxIndicators: 0,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/tradingeconomics-scraper').call(run_input={
    'mode': 'country-indicators',
    'countries': ['united-states', 'germany', 'china'],
    'categories': ['overview'],
    'maxIndicators': 0,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['country'], item['indicator'], item['value'], item['unit'])
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~tradingeconomics-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "country-list",
    "indicator": "inflation-rate",
    "maxIndicators": 0
  }'
```

### 🤖 Use with AI agents via MCP

TradingEconomics Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/tradingeconomics-scraper to get GDP data for all countries and show me the top 10 economies"
- "Scrape inflation rates across G7 countries and compare them to last year's data"
- "Get all economic indicators for Japan and identify which ones are at all-time highs"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### ⚖️ Is it legal to scrape TradingEconomics?

TradingEconomics displays **publicly available economic data** sourced from official government agencies, central banks, and international organizations (IMF, World Bank, Eurostat, etc.). The data is publicly available without login.

This scraper operates by reading publicly accessible web pages — the same data any browser user can view. It does not bypass authentication, access private data, or circumvent any technical protection measures.

As with any web scraping project, users are responsible for ensuring their use complies with applicable laws and the website's terms of service. This scraper is intended for legitimate research, analysis, and monitoring purposes. **Do not use it to build competing data products.**

For more information on ethical web scraping, see [Apify's guide to web scraping legality](https://apify.com/blog/is-web-scraping-legal).

### ❓ FAQ

**How many indicators are available?**
TradingEconomics covers 20 million economic indicators across 196 countries. A typical country page shows 100–500 indicators organized across 12 categories. The US indicators page, for example, returns ~408 items when all categories are scraped.

**How often is the data updated?**
Data frequency varies by indicator — GDP is typically quarterly, unemployment is monthly, interest rates are event-driven (central bank meetings), and financial market indicators (stock indices, currency) update daily or in real-time on the TradingEconomics website. Each scraped item includes a `reference` field showing the most recent reporting period.

**How fast is the scraper?**
Each page loads in about 1–2 seconds. Scraping all indicators for one country (one page load) takes ~2–3 seconds. Scraping 10 countries takes ~20–30 seconds. A country-list page (e.g., GDP for all 200 countries) is a single page load taking ~2 seconds.

**Why are some indicators missing highest/lowest values?**
The `highest` and `lowest` fields are only available on the country indicators page. The country-list pages (e.g., `/country-list/gdp`) don't show those columns, so they'll be `null` for country-list mode results.

**Why do I see fewer results than expected on country-list pages?**
TradingEconomics country-list pages typically show the top 20–30 countries by default. This is the data available on those pages without additional pagination or JavaScript. If you need all countries, use `country-indicators` mode and list all countries you need.

**Can I scrape historical data?**
This scraper extracts the current snapshot (latest value + previous period). Historical time-series data would require scraping individual indicator detail pages, which is not currently supported. For historical data, consider using TradingEconomics' API directly.

**The actor returned 0 results — what happened?**
This usually means TradingEconomics changed their HTML structure or the country/indicator slug you entered is incorrect. Check that your country slug matches the URL format exactly (e.g., `united-states` not `USA` or `us`). If the issue persists, please open an issue in the Apify console.

### 🔗 Related scrapers

Looking for more financial data? Check these automation-lab actors:

- [CoinGecko Scraper](https://apify.com/automation-lab/coingecko-scraper) — Cryptocurrency prices, market caps, and trading volumes
- [CoinMarketCap Scraper](https://apify.com/automation-lab/coinmarketcap-scraper) — Cryptocurrency rankings and market data
- [Investing.com Scraper](https://apify.com/automation-lab/investing-scraper) — Stocks, forex, commodities, and economic calendar
- [Yahoo Finance Scraper](https://apify.com/automation-lab/yahoo-finance-scraper) — Stock quotes, financials, and market news
- [Bing News Scraper](https://apify.com/automation-lab/bing-news-scraper) — Financial and economic news from Bing
- [ArXiv Scraper](https://apify.com/automation-lab/arxiv-scraper) — Academic papers on economics and finance

# Actor input Schema

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

Choose what to scrape. 'Country indicators' scrapes all indicators for one or more countries. 'Country list for indicator' scrapes a specific indicator across all countries. 'Direct URL' lets you enter any TradingEconomics URL.

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

List of countries to scrape (e.g. 'united-states', 'germany', 'china'). Used in 'Country indicators' mode. Use the country slug as it appears in TradingEconomics URLs.

## `categories` (type: `array`):

Filter by indicator categories. Leave empty to scrape all categories. Used in 'Country indicators' mode. Options: overview, gdp, labour, prices, money, trade, government, business, consumer, housing, energy, health.

## `indicator` (type: `string`):

Indicator to scrape across all countries (e.g. 'gdp', 'unemployment-rate', 'inflation-rate'). Used in 'Country list for indicator' mode.

## `directUrl` (type: `string`):

Full TradingEconomics URL to scrape (e.g. https://tradingeconomics.com/country-list/gdp). Used in 'Direct URL' mode.

## `maxIndicators` (type: `integer`):

Maximum number of indicators to scrape (0 = no limit).

## `proxy` (type: `object`):

Proxy settings. Datacenter proxies (BUYPROXIES94952) are recommended — TradingEconomics does not block scrapers.

## Actor input object example

```json
{
  "mode": "country-indicators",
  "countries": [
    "united-states",
    "germany"
  ],
  "categories": [],
  "indicator": "gdp",
  "directUrl": "https://tradingeconomics.com/country-list/gdp",
  "maxIndicators": 10,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# 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 = {
    "mode": "country-indicators",
    "countries": [
        "united-states",
        "germany"
    ],
    "categories": [],
    "indicator": "gdp",
    "directUrl": "https://tradingeconomics.com/country-list/gdp",
    "maxIndicators": 10,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "BUYPROXIES94952"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tradingeconomics-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": "country-indicators",
    "countries": [
        "united-states",
        "germany",
    ],
    "categories": [],
    "indicator": "gdp",
    "directUrl": "https://tradingeconomics.com/country-list/gdp",
    "maxIndicators": 10,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["BUYPROXIES94952"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tradingeconomics-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": "country-indicators",
  "countries": [
    "united-states",
    "germany"
  ],
  "categories": [],
  "indicator": "gdp",
  "directUrl": "https://tradingeconomics.com/country-list/gdp",
  "maxIndicators": 10,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}' |
apify call automation-lab/tradingeconomics-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradingEconomics Scraper",
        "description": "Extract economic indicators from TradingEconomics.com. Get GDP, inflation, unemployment, interest rates, and 20M+ indicators across 196 countries. No API key needed.",
        "version": "0.1",
        "x-build-id": "z0VfE0zmvxYYugYeR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tradingeconomics-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tradingeconomics-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/automation-lab~tradingeconomics-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tradingeconomics-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/automation-lab~tradingeconomics-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tradingeconomics-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": {
                    "mode": {
                        "title": "Scrape mode",
                        "enum": [
                            "country-indicators",
                            "country-list",
                            "direct-url"
                        ],
                        "type": "string",
                        "description": "Choose what to scrape. 'Country indicators' scrapes all indicators for one or more countries. 'Country list for indicator' scrapes a specific indicator across all countries. 'Direct URL' lets you enter any TradingEconomics URL.",
                        "default": "country-indicators"
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "List of countries to scrape (e.g. 'united-states', 'germany', 'china'). Used in 'Country indicators' mode. Use the country slug as it appears in TradingEconomics URLs.",
                        "default": [
                            "united-states"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Indicator categories",
                        "type": "array",
                        "description": "Filter by indicator categories. Leave empty to scrape all categories. Used in 'Country indicators' mode. Options: overview, gdp, labour, prices, money, trade, government, business, consumer, housing, energy, health.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "indicator": {
                        "title": "Indicator slug",
                        "type": "string",
                        "description": "Indicator to scrape across all countries (e.g. 'gdp', 'unemployment-rate', 'inflation-rate'). Used in 'Country list for indicator' mode.",
                        "default": "gdp"
                    },
                    "directUrl": {
                        "title": "Direct URL",
                        "type": "string",
                        "description": "Full TradingEconomics URL to scrape (e.g. https://tradingeconomics.com/country-list/gdp). Used in 'Direct URL' mode."
                    },
                    "maxIndicators": {
                        "title": "Max indicators",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of indicators to scrape (0 = no limit).",
                        "default": 0
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Datacenter proxies (BUYPROXIES94952) are recommended — TradingEconomics does not block scrapers."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
