# disease.sh Global Health Stats Scraper (`parseforge/disease-sh-health-stats-scraper`) Actor

Scrape global disease and public health statistics from disease.sh public API. COVID-19, influenza, and vaccine data by country, state, county with historical timeline. No API key required.

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

## Pricing

from $30.23 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/parseforge-banner.png)

## 🦠 disease.sh Global Health Stats Scraper

> 🚀 **Pull worldwide public health statistics in seconds.** Filter by country, US state, continent, or global totals. No API key, no registration, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-12 · **📊 Up to 26 fields** per record · **195+ countries** indexed · **All 50 US states plus territories** · **Vaccine coverage timelines** included

The disease.sh Global Health Stats Scraper pulls structured public health data from the open **disease.sh** API, a community-maintained aggregator that surfaces Johns Hopkins, Worldometers, and CDC-style data sources in one unified shape. The actor exposes five scopes: **by country**, **by US state**, **by continent**, **global totals**, and **vaccine coverage by country**. Every record carries normalized counts, per-million ratios, population, ISO codes, and lat/long when available, so you can join it to maps, dashboards, or BI tools with no extra cleanup.

Country records include cases, today's cases, deaths, today's deaths, recovered, active, critical, total tests, tests per million, and population. Per-million ratios are also pre-computed for cases, deaths, tests, active, recovered, and critical. State records carry the same metrics scoped to US states. Continent records aggregate up. The vaccine scope returns a country-level coverage timeline. The result is a clean feed ready for epidemiological reports, public-interest dashboards, course material, or a research notebook.

| 🎯 Target audience | 💼 Primary use cases |
|---|---|
| Public health researchers | Cross-country comparisons of case and death rates |
| Data journalists | Source up-to-date stats for explainers and visualizations |
| Educators | Build classroom datasets for data science and epidemiology |
| NGOs and policy teams | Track vaccine coverage and active case trends |
| Civic tech projects | Power community dashboards and transparency tools |

---

### 📋 What the disease.sh Health Stats Scraper does

- 🌍 **Scope picker.** Choose `countries`, `states`, `continents`, `all` (global totals), or `vaccineCoverage` in one click.
- 🔃 **Sort modes.** Sort countries and states by `cases`, `deaths`, `todayCases`, `todayDeaths`, `active`, `tests`, `recovered`, or alphabetical country name.
- 🧮 **Per-million ratios built in.** Cases per million, deaths per million, tests per million, active per million, recovered per million, critical per million.
- 🏳️ **ISO codes and geography.** Each country record includes ISO 2 and ISO 3, continent name, latitude, longitude, and a flag image URL.
- 💉 **Vaccine timelines.** The `vaccineCoverage` scope returns the per-country last-day total dose figures keyed by date.
- 📋 **Uniform schema across scopes.** A `scope` discriminator on every record lets you union country, state, continent, global, and vaccine rows in one table.

Each record carries a `scope` field (`country`, `state`, `continent`, `global`, or `vaccine`) and a `scrapedAt` timestamp. Country and state records use a consistent core set of metrics so dashboards can flip between geographies without re-wiring columns.

> 💡 **Why it matters:** Public health data drives policy, research, and journalism. A clean, ready-to-query feed saves you hours of CSV wrangling and lets you focus on insight rather than parsing.

---

### 🎬 Full Demo

🚧 Coming soon: a 3-minute walkthrough showing how to pick a scope, set a sort, and route results into a spreadsheet or dashboard.

---

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Description</th></tr>
<tr><td><code>scope</code></td><td>enum</td><td>One of <code>countries</code>, <code>states</code>, <code>continents</code>, <code>all</code>, or <code>vaccineCoverage</code>. Default <code>countries</code>.</td></tr>
<tr><td><code>sort</code></td><td>enum</td><td>Sort for countries and states. One of <code>cases</code>, <code>deaths</code>, <code>todayCases</code>, <code>todayDeaths</code>, <code>active</code>, <code>tests</code>, <code>recovered</code>, or <code>country</code>. Default <code>cases</code>.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>Free users 10, paid users up to 1,000,000.</td></tr>
</table>

Example: top 50 countries by total deaths.

```json
{
  "scope": "countries",
  "sort": "deaths",
  "maxItems": 50
}
````

Example: global totals snapshot.

```json
{
  "scope": "all",
  "maxItems": 1
}
```

> ⚠️ **Good to Know:** disease.sh aggregates public sources and may lag the official publications by minutes to hours. Some country records report zeros for recovered or active depending on whether the upstream source still publishes those fields.

***

### 📊 Output

Each record is a flat JSON object with the fields below. Field availability depends on the chosen scope.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🌍 `scope` | string | `country` |
| 🖼️ `imageUrl` | string | `https://disease.sh/assets/img/flags/us.png` |
| ⏱️ `updated` | string | `2026-05-12T16:27:22.762Z` |
| 🏷️ `country` | string | `USA` |
| 🏳️ `iso2` | string | `US` |
| 🏳️ `iso3` | string | `USA` |
| 🌐 `continent` | string | `North America` |
| 🗺️ `latitude` | number | `38` |
| 🗺️ `longitude` | number | `-97` |
| 🧮 `cases` | number | `111820082` |
| 🆕 `todayCases` | number | `0` |
| ⚰️ `deaths` | number | `1219487` |
| ⚰️ `todayDeaths` | number | `0` |
| 💚 `recovered` | number | `109814428` |
| 🟢 `todayRecovered` | number | `0` |
| 🟡 `active` | number | `786167` |
| 🚨 `critical` | number | `940` |
| 📊 `casesPerOneMillion` | number | `333985` |
| 📊 `deathsPerOneMillion` | number | `3642` |
| 🧪 `tests` | number | `1186851502` |
| 🧪 `testsPerOneMillion` | number | `3544901` |
| 👥 `population` | number | `334805269` |
| 1️⃣ `oneCasePerPeople` | number | `3` |
| 1️⃣ `oneDeathPerPeople` | number | `275` |
| 1️⃣ `oneTestPerPeople` | number | `0` |
| ⏱️ `scrapedAt` | string | `2026-05-12T16:30:28.409Z` |

#### 📦 Sample records

<details>
<summary>Typical: large country with full metric set</summary>

```json
{
  "scope": "country",
  "updated": "2026-05-12T16:27:22.762Z",
  "imageUrl": "https://disease.sh/assets/img/flags/us.png",
  "country": "USA",
  "iso2": "US",
  "iso3": "USA",
  "continent": "North America",
  "latitude": 38,
  "longitude": -97,
  "cases": 111820082,
  "todayCases": 0,
  "deaths": 1219487,
  "todayDeaths": 0,
  "recovered": 109814428,
  "active": 786167,
  "critical": 940,
  "casesPerOneMillion": 333985,
  "deathsPerOneMillion": 3642,
  "tests": 1186851502,
  "testsPerOneMillion": 3544901,
  "population": 334805269,
  "scrapedAt": "2026-05-12T16:30:28.409Z"
}
```

</details>

<details>
<summary>Edge case: large country with zero recovered field</summary>

```json
{
  "scope": "country",
  "updated": "2026-05-12T16:27:22.764Z",
  "imageUrl": "https://disease.sh/assets/img/flags/in.png",
  "country": "India",
  "iso2": "IN",
  "iso3": "IND",
  "continent": "Asia",
  "cases": 45035393,
  "deaths": 533570,
  "recovered": 0,
  "active": 44501823,
  "casesPerOneMillion": 32016,
  "deathsPerOneMillion": 379,
  "tests": 935879495,
  "population": 1406631776,
  "scrapedAt": "2026-05-12T16:30:28.409Z"
}
```

</details>

<details>
<summary>Sparse: country with zero active and critical</summary>

```json
{
  "scope": "country",
  "updated": "2026-05-12T16:27:22.766Z",
  "imageUrl": "https://disease.sh/assets/img/flags/fr.png",
  "country": "France",
  "iso2": "FR",
  "iso3": "FRA",
  "continent": "Europe",
  "cases": 40138560,
  "deaths": 167642,
  "recovered": 39970918,
  "active": 0,
  "critical": 0,
  "casesPerOneMillion": 612013,
  "deathsPerOneMillion": 2556,
  "tests": 271490188,
  "population": 65584518,
  "scrapedAt": "2026-05-12T16:30:28.409Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🆓 | **No API key.** disease.sh is open and free, and this actor inherits that. |
| 🌍 | **Five scopes in one actor.** Countries, states, continents, global, vaccines. |
| 🧮 | **Per-million ratios baked in.** No manual division to compare across populations. |
| 🏳️ | **ISO codes and lat/long.** Drop straight into maps and join tables. |
| 🔃 | **Eight sort options.** Cases, deaths, today's totals, active, tests, recovered, or country name. |
| ⚡ | **One API call per scope.** Fast even on the largest country list. |
| 🔌 | **Integrates everywhere.** Land results in Sheets, Notion, Slack, or a database. |

> 📊 5 scopes, 26 fields per country record, 1 free actor.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ disease.sh Health Stats Scraper** *(this Actor)* | Free tier available | Global, country, state, continent, vaccine | Hourly upstream | Scope, sort | One JSON input |
| Official publications | Free | Per-issuer, fragmented | Daily | Manual | Browser or PDF parsing |
| Paid epidemiology platforms | $200+ per month | Often broader | Daily | Vendor-specific | Account, key, SDK |
| Legacy community CSV dumps | Free | Stale snapshots | None | None | Manual download |

For teams that need a current, unified health stats feed without writing API client code, this actor is the shortest path from question to row.

***

### 🚀 How to use

1. 🔐 **Create a free Apify account.** Sign up at [Apify](https://console.apify.com/sign-up?fpr=vmoqkp) and claim the $5 starter credit.
2. 🌍 **Pick a scope.** Choose countries, states, continents, global totals, or vaccine coverage.
3. 🔃 **Set the sort.** For country and state scopes, sort by cases, deaths, today's totals, or alphabetical.
4. ▶️ **Run it.** Free users get a 10-row preview, paid users can pull up to 1,000,000 records per run.
5. 📤 **Export.** Download JSON, CSV, or Excel, or push results into Google Sheets, Airtable, Slack, Notion, or a database via Apify integrations.

> ⏱️ Total time from sign-up to first dataset: about 90 seconds.

***

### 💼 Business use cases

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

#### 🏥 Public health and policy

- Cross-country case and death rate comparisons
- Vaccine coverage progress tracking
- Active and critical case alerting
- ISO-coded joins to demographic and economic data

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

#### 📰 Newsrooms and explainers

- Up-to-date numbers for live news pages
- Per-million normalization for fair comparisons
- Source data for explainer charts and maps
- Quick verification of viral health claims

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

#### 📊 Analytics and BI

- Dashboards with country, state, and continent drilldowns
- Long-horizon studies of case and test trends
- Population-normalized leaderboards
- Geo-coded data for spatial analytics

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

#### 🧑‍🏫 Education and training

- Classroom datasets for statistics courses
- Reproducible epidemiology homework
- Demo data for data-engineering bootcamps
- ETL pipeline practice with a real upstream API

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

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

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

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

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

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

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

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

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

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

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

***

### 🔌 Automating disease.sh Health Stats Scraper

Drive this actor from your own stack with a few lines of code.

- Trigger runs from **Node.js** using the [Apify JavaScript client](https://docs.apify.com/api/client/js/)
- Trigger runs from **Python** using the [Apify Python client](https://docs.apify.com/api/client/python/)
- Read the [Apify REST API docs](https://docs.apify.com/api/v2) to call the actor over HTTP

Schedules let you refresh country totals every hour, snapshot the vaccine coverage timeline daily, or watch a continent during a public health event.

***

### ❓ Frequently Asked Questions

#### 💰 Is there a cost to run this Actor?

The actor itself is free to use on Apify. You pay only for the platform compute and storage you consume during a run. New accounts come with $5 of starter credit, which covers many small runs.

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

No. disease.sh is fully open and unauthenticated. The actor reaches the upstream directly with no key or token required.

#### 🌍 Which scopes are available?

Five scopes: `countries` (every country), `states` (US states), `continents` (continent aggregates), `all` (global totals), and `vaccineCoverage` (per-country dose timelines).

#### 🔃 How can I sort the results?

Country and state scopes support sorting by `cases`, `deaths`, `todayCases`, `todayDeaths`, `active`, `tests`, `recovered`, or alphabetical `country`. Default is `cases` descending.

#### 🧮 Are the per-million ratios pre-computed?

Yes. Each country record carries `casesPerOneMillion`, `deathsPerOneMillion`, `testsPerOneMillion`, `activePerOneMillion`, `recoveredPerOneMillion`, and `criticalPerOneMillion` so you can compare across populations without manual division.

#### 🤝 Can I use this Actor for commercial use?

Yes. disease.sh aggregates publicly available statistics from government and health authority sources. You are responsible for following the upstream terms and any local rules that apply to your use of public-health information.

#### 💳 Do I need a paid Apify plan?

A paid plan is not required. Free accounts can preview up to 10 rows per run. Paid plans unlock up to 1,000,000 rows per run plus larger storage and compute budgets.

#### 🆘 What if a run fails?

Open the run in the Apify console to inspect the log, the input, and any partial dataset. Network errors and upstream rate limits are surfaced as `error` items in the dataset rather than as silent crashes.

#### ⚖️ Is scraping this data legal?

Disease and public-health statistics published by health authorities are public information. This actor reads only the public disease.sh API with no login or token, so the data flow is the same one any browser or curl request would produce. Compliance with the source terms and local law remains your responsibility.

#### 💉 What does the vaccine scope return?

A per-country record with the ISO 3 code and a `timeline` object that maps a date to a total dose count for the most recent published day.

#### 🔄 How fresh is the data?

disease.sh aggregates public sources several times per day. Each run reads the live API, so values reflect the most recent upstream refresh at the moment of the request.

***

### 🔌 Integrate with any app

Stream results into the tools your team already uses.

- [**Make**](https://apify.com/integrations) - low-code automation across thousands of apps
- [**Zapier**](https://apify.com/integrations) - trigger and route data into 6,000+ services
- [**n8n**](https://apify.com/integrations) - self-hosted workflow runner with native Apify support
- [**Slack**](https://apify.com/integrations) - notifications when runs complete or hit anomalies
- [**Google Sheets**](https://apify.com/integrations) - one-click dataset to spreadsheet sync
- [**BigQuery and Snowflake**](https://apify.com/integrations) - warehouse loads via webhook or schedule

***

### 🔗 Recommended Actors

- [**🌐 Wikidata Entity Search Scraper**](https://apify.com/parseforge/wikidata-entity-search-scraper) - enrich country records with structured entity references
- [**📚 Open Library Scraper**](https://apify.com/parseforge/open-library-scraper) - source epidemiology book metadata for research
- [**🔎 CrossRef Scraper**](https://apify.com/parseforge/crossref-scraper) - pull peer-reviewed public health research papers
- [**🪙 OpenAlex Scraper**](https://apify.com/parseforge/openalex-scraper) - open scholarly graph for citation work
- [**📈 GitHub Trending Scraper**](https://apify.com/parseforge/github-trending-scraper) - find open-source health data tooling

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more data feeds across research, civic, and analytics ecosystems.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) and a human will reply within one business day.

***

> This Actor accesses publicly available data only. By using it you accept the responsibility to comply with the source's Terms of Service, rate limits, and applicable laws including data-protection regulations. The data is scraped on-demand from the upstream public API and is not cached or pre-stored by this Actor.

# Actor input Schema

## `scope` (type: `string`):

Which slice of disease.sh data to scrape

## `sort` (type: `string`):

Sort countries / states by this field

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

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

## Actor input object example

```json
{
  "scope": "countries",
  "sort": "cases",
  "maxItems": 10
}
```

# Actor output Schema

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

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

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

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/disease-sh-health-stats-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 = {
    "scope": "countries",
    "maxItems": 10,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "disease.sh Global Health Stats Scraper",
        "description": "Scrape global disease and public health statistics from disease.sh public API. COVID-19, influenza, and vaccine data by country, state, county with historical timeline. No API key required.",
        "version": "0.0",
        "x-build-id": "mq6nrBiWrwbcjHkXu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~disease-sh-health-stats-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-disease-sh-health-stats-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~disease-sh-health-stats-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-disease-sh-health-stats-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~disease-sh-health-stats-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-disease-sh-health-stats-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": {
                    "scope": {
                        "title": "Scope",
                        "enum": [
                            "countries",
                            "states",
                            "continents",
                            "all",
                            "vaccineCoverage"
                        ],
                        "type": "string",
                        "description": "Which slice of disease.sh data to scrape",
                        "default": "countries"
                    },
                    "sort": {
                        "title": "Sort (countries / states)",
                        "enum": [
                            "cases",
                            "deaths",
                            "todayCases",
                            "todayDeaths",
                            "active",
                            "tests",
                            "recovered",
                            "country"
                        ],
                        "type": "string",
                        "description": "Sort countries / states by this field",
                        "default": "cases"
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
