# PokeAPI Pokemon Data Scraper (`parseforge/pokeapi-pokemon-scraper`) Actor

Scrape Pokemon data from PokeAPI by name, ID, or in bulk. Returns stats, types, abilities, and sprite URLs in a flat row. No API key required.

- **URL**: https://apify.com/parseforge/pokeapi-pokemon-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Games
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### PokeAPI Pokemon Data Scraper

**Scrape Pokemon data from PokeAPI by name, ID, or in bulk, up to a million per run.** Every Pokemon comes with its stats, types, abilities, sprites, and species details. No API key or registration needed. Export to CSV, JSON, Excel, or XML.

PokeAPI's REST endpoints are free but rate-limited and require you to handle pagination, nested resources, and schema mapping yourself. This Actor reads the public PokeAPI directly, fetches Pokemon by name or ID, or pulls a full list, and returns each one in a flat, consistent row. You get clean, analysis-ready Pokemon data without writing a single request.

| Who uses it | What they scrape PokeAPI for |
|---|---|
| Game data analysts | Compare base stats and type distributions across all Pokemon generations. |
| Bot and app developers | Populate a local database with Pokemon sprites, abilities, and metadata for a fan app or Discord bot. |
| Content creators | Pull the latest Pokemon data for wiki entries, YouTube infographics, or community guides. |
| Competitive battlers | Export full stat blocks and type matchups to build team-building tools or damage calculators. |

### What it does

This Actor collects Pokemon data from PokeAPI by name, ID, or as a bulk list, and returns each Pokemon as a flat row with its stats, types, abilities, sprites, and more.

- 🔍 **Single lookup:** fetch one Pokemon by exact name or national Pokedex ID, like pikachu or 25.
- 📊 **Bulk extraction:** pull up to a million Pokemon in one run, each returned as a flat, predictable row.
- 🖼️ **Sprites included:** official artwork and sprite URLs are part of every record so you can display them directly.
- 📈 **Computed stats:** base HP, Attack, Defense, Special Attack, Special Defense, and Speed are all flattened into columns.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with PokeAPI data

**📊 Build a local Pokedex database.**

A game data analyst runs the Actor with maxItems set to 1025 and exports the full dataset to CSV for a Tableau dashboard comparing base stats by generation.

**🤖 Power a Discord bot or fan app.**

A developer fetches all Pokemon with their sprites and types, then seeds a MongoDB collection that backs a slash-command bot for their community server.

**🎨 Generate infographics and video assets.**

A content creator pulls the latest Pokemon data and official artwork URLs, then feeds them into a Canva template to produce a weekly type-effectiveness chart.

**⚔️ Populate a competitive team builder.**

A competitive battler scrapes base stats and type data for every fully evolved Pokemon, then imports the CSV into a damage calculator to test team compositions.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key or OAuth** | Reads public PokeAPI endpoints directly, no registration or token management. |
| **Flat, fixed schema** | Nested abilities, types, and stats are flattened into one row per Pokemon, ready for spreadsheets. |
| **Sprite URLs included** | Official artwork and sprite links ship with every record so you can render images immediately. |
| **Bulk-friendly** | Pull up to a million Pokemon in a single run, filtered only by the count you set. |

### How it compares

This Actor focuses on flat, analysis-ready output and bulk extraction without API keys, while some competitors add built-in generation or type filters.

| Feature | ParseForge | PokeAPI Pokemon Data Scraper | Pokemon Data Scraper (PokeAPI) | PokeAPI Scraper - Pokémon Data |
|---|---|---|---|---|
| No API key required | Yes | Not listed | Yes | Not listed |
| Bulk extraction up to 1M Pokemon | Yes | Not listed | Not listed | Not listed |
| Filter by generation or type | Not listed | Yes | Not listed | Yes |
| Sprite and artwork URLs | Yes | Yes | Not listed | Yes |
| Flat row output (stats, types, abilities) | Yes | Not listed | Not listed | Not listed |
| Single Pokemon lookup by name or ID | Yes | Not listed | Not listed | Yes |

### Configure the run

Drive the Actor with a single Pokemon name or ID, or leave the input empty to pull a full list, and set a maximum item count to control the run size. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "searchQuery": "pikachu",
 "maxItems": 10
}
```

A larger pull:

```json
{
 "searchQuery": "pikachu",
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [PokeAPI Pokemon Data Scraper](https://apify.com/parseforge/pokeapi-pokemon-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to PokeAPI through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/pokeapi-pokemon-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that you entered a valid Pokemon name or ID. Names are case-sensitive and must match PokeAPI's exact spelling (e.g., 'pikachu', not 'Pikachu'). If you left the name empty, ensure maxItems is set to a number greater than 0.

**Why does my run stop after 10 Pokemon?**

Free Apify accounts are limited to 10 results as a preview. Upgrade to a paid plan to increase maxItems up to 1,000,000.

**Why are some sprite URLs broken?**

PokeAPI occasionally updates its asset paths. If a sprite URL returns a 404, the data itself is still valid. Try re-running the Actor after a few hours, or check PokeAPI's status page for any ongoing changes.

**Why is the run slow when I fetch thousands of Pokemon?**

The Actor respects PokeAPI's rate limits to avoid being blocked. Large bulk runs will take longer. You can reduce maxItems or run the Actor during off-peak hours for faster throughput.

**Why do I get a 'Pokemon not found' error?**

The name or ID you entered does not match any Pokemon in PokeAPI. Double-check the spelling or try the national Pokedex ID instead. Note that regional variants have specific names (e.g., 'pikachu-rock-star').

### FAQ

| Question | Answer |
|---|---|
| Do I need a PokeAPI account or API key? | No. This Actor reads the public PokeAPI endpoints directly. You do not need to register, obtain a key, or handle OAuth. |
| How many Pokemon can I scrape in one run? | Free users are limited to 10 Pokemon as a preview. Paid Apify plans can set maxItems up to 1,000,000, which covers the entire Pokedex many times over. |
| What data fields does each Pokemon row include? | Every row returns the Pokemon's name, ID, base stats (HP, Attack, Defense, Special Attack, Special Defense, Speed), types, abilities, official sprite URLs, and species details. The exact field list is shown in the sample output on the Actor's page. |
| Can I filter by generation or type? | This Actor fetches Pokemon by name, ID, or as a full list. It does not have built-in generation or type filters. You can apply those filters in your own code or spreadsheet after the data is exported. |
| How do I get only one specific Pokemon? | Enter the Pokemon's exact name (e.g., pikachu) or its national Pokedex ID (e.g., 25) in the 'Pokemon Name' input field and leave maxItems at 1. |
| Are the sprites and artwork URLs included? | Yes. Official artwork and sprite URLs are part of every record so you can display the images directly in your app or report. |
| What output formats are supported? | You can export your dataset to CSV, JSON, Excel, or XML from the Apify dataset tab after the run completes. |
| Does this Actor handle rate limiting? | Yes. The Actor respects PokeAPI's rate limits automatically and retries on failure, so you do not need to manage backoff logic. |
| Can I schedule this Actor to run daily? | Yes. Apify supports scheduled runs. You can set this Actor to run on a cron schedule and receive new Pokemon data automatically if the API is updated. |
| What happens if I enter an invalid Pokemon name? | The Actor will log an error for that specific request and continue with the next item if running in bulk. In single-lookup mode, the run will fail with a clear error message. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by PokeAPI. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `searchQuery` (type: `string`):

Optional. A single Pokemon name or id to fetch directly (for example pikachu, ditto, 25). Leave empty to pull a list of Pokemon instead.

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

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

## Actor input object example

```json
{
  "searchQuery": "pikachu",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQuery": "pikachu",
    "maxItems": 10
};

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

# Run the Actor and wait for it to finish
run = client.actor("parseforge/pokeapi-pokemon-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "pikachu",
  "maxItems": 10
}' |
apify call parseforge/pokeapi-pokemon-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/pokeapi-pokemon-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hK55RoaDqqtLbJH22/builds/70ipcGZHhYSSyyRYW/openapi.json