# Pokémon Pokédex Data API (`automation-lab/pokemon-pokedex-data-api`) Actor

Search Pokémon by name or Pokédex ID and export normalized species, forms, types, abilities, moves, stats, evolutions, encounters, game versions, and sprite provenance.

- **URL**: https://apify.com/automation-lab/pokemon-pokedex-data-api.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Games
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.44 / 1,000 item extracteds

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/actors/running/actors-in-store.md#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

## Pokémon Pokédex Data API

Build clean Pokémon datasets without manually joining multiple endpoints.
This Actor searches supplied Pokémon names or National Pokédex IDs and exports
one normalized record per Pokémon from the public PokeAPI.

Each record combines species, forms, types, abilities, moves, base stats,
evolution chains, encounters, game-version references, and sprite provenance.
It is useful for games, fan tools, search products, spreadsheets, and recurring
reference-data refreshes.

A version filter supports workflows such as a **Pokémon Fire Red Pokédex** while
keeping the stable record shape used by broader National Pokédex exports.

### What does this Pokémon data Actor do?

The Actor accepts a list such as `pikachu`, `charizard`, and `150`.
For every valid entry it retrieves and joins these public resources:

1. Pokémon details;
2. species details;
3. the linked evolution chain;
4. location-area encounters, unless disabled.

It deduplicates repeated inputs and saves only useful normalized records.
Unknown names or IDs are logged and skipped without charging an item event.
Stable upstream failures stop the run instead of returning misleading empty data.

### Who is it for?

- Game developers prototyping mechanics or lookup screens.
- Fan-site builders creating searchable Pokédex pages.
- Data analysts comparing stats, types, generations, and move availability.
- Educators preparing structured examples for API or data lessons.
- Automation teams refreshing a known set of Pokémon on a schedule.
- Spreadsheet users who need JSON, CSV, Excel, XML, or RSS dataset exports.

### Why use this instead of raw API calls?

PokeAPI is an excellent public source, but a complete entity spans linked
resources. This Actor performs those joins, applies one consistent input limit,
normalizes nested fields, retries temporary failures, and writes an
integration-ready Apify dataset.

You also get scheduling, webhooks, API access, dataset retention, exports, and
Apify integrations without maintaining a separate job runner.

### What Pokémon data is extracted?

| Field | Meaning |
| --- | --- |
| `pokemonId`, `name`, `pokedexNumber` | Canonical identity and National Pokédex number |
| `species` | English genus, generation, habitat, color, shape, flags, varieties |
| `forms` | Form names and canonical PokeAPI URLs |
| `types` | Ordered elemental types |
| `abilities` | Ability slot and hidden-ability status |
| `stats` | Base stat and effort value for each stat |
| `moves` | Move, learning methods, and version groups |
| `evolutionChain` | Flattened chain, parent, trigger, level, and conditions |
| `encounters` | Location areas, game versions, chances, and methods |
| `gameVersions` | Referenced versions and version groups |
| `height`, `weight` | PokeAPI decimetres and hectograms |
| `baseExperience` | Base experience when exposed upstream |
| `sprites` | Original nested sprite and artwork URL tree |
| `spriteProvenance` | Upstream source and repository guidance |
| `sourceUrl`, `speciesUrl` | Canonical source endpoints |
| `fetchedAt` | UTC retrieval timestamp |

### Getting started

1. Open the Actor in Apify Console.
2. Enter Pokémon names or IDs in **Pokémon names or IDs**.
3. Optionally add a game version filter such as `fire-red`.
4. Keep moves and encounters enabled for the richest record.
5. Set a maximum record count.
6. Click **Start**.
7. Open the **Pokédex records** dataset view.
8. Export or connect the dataset to your next workflow.

A useful first input is:

```json
{
  "pokemon": ["pikachu", "charizard", "1"],
  "maxItems": 3
}
```

### Input parameters

#### `pokemon`

A non-empty list of names or National Pokédex IDs represented as strings.
Names are lowercased and spaces become hyphens.
Duplicate values are removed while preserving first-seen order.
The default is a small three-Pokémon sample.

#### `version`

Optional PokeAPI version or version-group slug.
Examples include `fire-red`, `emerald`, and `scarlet-violet`.
It filters move version groups and encounter versions.
It does not claim that every species exists in that game's regional Pokédex.

#### `includeMoves`

Defaults to `true`.
Set it to `false` to omit the potentially large move collection.

#### `includeEncounters`

Defaults to `true`.
Set it to `false` to skip the extra encounter endpoint and reduce output size.

#### `maxItems`

Maximum number of unique records, from 1 to 1,000.
Processing stops before any input beyond this limit is fetched.

### Pokémon Fire Red Pokédex example

Use version filtering when you need Fire Red move and encounter context:

```json
{
  "pokemon": ["pikachu", "charizard", "mewtwo"],
  "version": "fire-red",
  "includeMoves": true,
  "includeEncounters": true,
  "maxItems": 3
}
```

The resulting records retain general species data while move and encounter
arrays include matching Fire Red references.
Supply the exact Pokémon set relevant to your project.

### Output example

The live output is richer than this shortened example:

```json
{
  "pokemonId": 25,
  "name": "pikachu",
  "pokedexNumber": 25,
  "types": [{ "slot": 1, "name": "electric" }],
  "abilities": [
    { "slot": 1, "name": "static", "isHidden": false },
    { "slot": 3, "name": "lightning-rod", "isHidden": true }
  ],
  "stats": [
    { "name": "hp", "baseStat": 35, "effort": 0 },
    { "name": "speed", "baseStat": 90, "effort": 2 }
  ],
  "forms": [
    { "name": "pikachu", "url": "https://pokeapi.co/api/v2/pokemon-form/25/" }
  ],
  "sourceUrl": "https://pokeapi.co/api/v2/pokemon/25/",
  "speciesUrl": "https://pokeapi.co/api/v2/pokemon-species/25/"
}
```

Use the dataset API without `view=overview` to retrieve every nested field.

### How much does it cost to export Pokémon Pokédex records?

Pay-per-event pricing has two parts:

- **$0.00005** once when a run starts;
- the tier price for each successfully saved Pokémon record.

Current item tiers are:

| Plan | Price per Pokémon |
| --- | ---: |
| Free | $0.00276 |
| Bronze | $0.00240 |
| Silver | $0.001872 |
| Gold | $0.00144 |
| Platinum | $0.00144 |
| Diamond | $0.00144 |

At Bronze rates, 10 records cost about **$0.02405** including the start event,
100 records cost about **$0.24005**, and 1,000 records cost about **$2.40005**.
Unknown, duplicate, failed, or skipped identifiers do not emit item charges.
Platform usage remains subject to your Apify plan.

### Scheduling recurring data refreshes

Create an Apify Task with the stable Pokémon list your product uses.
Schedule it daily, weekly, or before a release.
Send the completed dataset to cloud storage, a webhook, or your own database.
Compare the current dataset with the previous run to identify upstream changes.

The Actor itself emits current snapshots.
It does not maintain history, send alerts, or calculate diffs automatically.

### Spreadsheet and data-pipeline workflows

After a run, export the dataset as JSON, CSV, Excel, XML, or RSS.
Nested arrays work best in JSON.
For tabular tools, choose the fields needed for your table or flatten them in a
post-processing step.

Typical workflows include:

- populate a game prototype's reference table;
- enrich a list of Pokémon IDs from user activity;
- generate static pages for a fan guide;
- cache sprite URLs with provenance alongside records;
- compare type and stat distributions in a notebook.

### Use the Actor through the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~pokemon-pokedex-data-api/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"pokemon":["pikachu","150"],"maxItems":2}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/pokemon-pokedex-data-api').call({
  pokemon: ['bulbasaur', 'charmander', 'squirtle'],
  maxItems: 3,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/pokemon-pokedex-data-api").call(
    run_input={"pokemon": ["pikachu", "mewtwo"], "maxItems": 2}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use it with MCP and AI agents

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/pokemon-pokedex-data-api"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code clients can use this HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/pokemon-pokedex-data-api"
    }
  }
}
```

Example prompts:

- “Get types, base stats, and evolutions for Pokémon IDs 1, 4, and 7.”
- “Build Fire Red move and encounter records for Pikachu and Charizard.”
- “Export these Pokémon records and summarize their speed distribution.”

### Reliability and retry behavior

The Actor uses direct public JSON endpoints and does not require a proxy or API
key for PokeAPI.
Temporary HTTP 429 and common 5xx responses are retried up to three times with
backoff.
A missing Pokémon is skipped with a warning.
Unexpected response formats and stable upstream errors fail the run visibly.

Requests are intentionally conservative rather than highly concurrent.
This protects upstream reliability and keeps memory usage low.

### Limits and data freshness

- Data reflects PokeAPI at run time, not official Nintendo release guarantees.
- A version filter is a relationship filter, not a regional-Pokédex membership test.
- Move arrays and sprite trees can be large.
- Encounter availability varies by Pokémon and version.
- Some modern forms or game data may lag their original release.
- The Actor does not download sprite image binaries.
- Maximum input size is 1,000 unique records per run.

For source issues, first verify the corresponding PokeAPI endpoint.

### Sprite provenance and responsible asset use

Sprite URLs come from the PokeAPI response.
The output names the PokeAPI sprites repository as provenance and deliberately
avoids claiming one blanket asset license.
Review the upstream repository, source attribution, and rights applicable to
your intended use before redistributing artwork.

Pokémon names and imagery are trademarks or intellectual property of their
respective owners.
This Actor is not affiliated with Nintendo, Game Freak, The Pokémon Company, or
PokeAPI.

### Legal and responsible use

PokeAPI is a public community API.
Use reasonable run sizes and schedules, honor upstream guidance, and avoid
creating unnecessary request load.
You are responsible for complying with applicable terms, licenses, trademark
rules, and laws.
Do not treat this tool as permission to redistribute protected media.

### Troubleshooting

#### A Pokémon produced no row

Check spelling or use its National Pokédex ID.
The Actor logs a warning when PokeAPI returns 404.
Use canonical slugs such as `mr-mime` where punctuation is involved.

#### Moves or encounters are empty

Remove the `version` filter to confirm the base data.
Then use a PokeAPI version or version-group slug that appears for that Pokémon.
Some Pokémon have no encounter data in a selected game.

#### The run failed with a PokeAPI error

Inspect the run log and retry later if the upstream API was temporarily
unavailable.
Repeated stable errors should be reported with the input and run URL.

#### The exported CSV looks nested

Use JSON for complete nested structures, or select and flatten fields for a
spreadsheet-oriented downstream table.

### FAQ

#### Does this search every Pokémon automatically?

No. It processes the names or IDs you supply so runs remain intentional and
bounded.

#### Can I search by Pokédex ID?

Yes. Add the ID as a string, for example `"25"` for Pikachu.

#### Is this limited to Pokémon Fire Red?

No. Fire Red is one supported version-filtered workflow.
The Actor can retrieve general records or filter moves and encounters for other
PokeAPI version slugs.

#### Does it download sprite files?

No. It exports the source URLs and provenance metadata.

#### Are forms separate charged records?

No. Forms, moves, encounters, and evolutions are included inside the one
Pokémon item event. Only saved top-level Pokémon records are item-charged.

#### Can I schedule it?

Yes. Save an Apify Task and add a schedule for recurring refreshes.

### Related Automation Lab Actors

For general API and dataset workflows, explore the
[Automation Lab Apify Store profile](https://apify.com/automation-lab).
No other portfolio Actor currently provides a closer Pokémon-specific companion,
so this product is positioned as a standalone reference-data workflow rather
than linking unrelated scrapers.

### Data source acknowledgment

This product uses data from [PokeAPI](https://pokeapi.co/), a community-maintained
REST API.
Source URLs are retained in every output row for traceability.

# Actor input Schema

## `pokemon` (type: `array`):

Pokémon names or National Pokédex IDs. Duplicate values are removed.

## `version` (type: `string`):

Optional lowercase PokeAPI version or version-group slug, such as fire-red or scarlet-violet. Filters moves and encounters.

## `includeMoves` (type: `boolean`):

Include move names, learning methods, and version groups.

## `includeEncounters` (type: `boolean`):

Fetch location-area encounter records. Disable for a smaller and faster dataset.

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

Maximum number of unique Pokémon records to export.

## Actor input object example

```json
{
  "pokemon": [
    "pikachu",
    "charizard",
    "1"
  ],
  "includeMoves": true,
  "includeEncounters": true,
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing normalized Pokémon data.

# 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 = {
    "pokemon": [
        "pikachu",
        "charizard",
        "1"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/pokemon-pokedex-data-api").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 = { "pokemon": [
        "pikachu",
        "charizard",
        "1",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/pokemon-pokedex-data-api").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 '{
  "pokemon": [
    "pikachu",
    "charizard",
    "1"
  ]
}' |
apify call automation-lab/pokemon-pokedex-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/pokemon-pokedex-data-api"
        }
    }
}

```

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/VscHg607UNuNXQfnY/builds/XopQOtOPbpf1jEau5/openapi.json