# PokéAPI MCP > PokéAPI gives your AI client access to the definitive database of Pokémon data—stats, moves, types, abilities, and evolution chains. Forget reading massive wikis; you ask for it in natural language (e.g., 'What resists Fire?' or 'Show me Pikachu's stats'), and the agent runs the lookup via specialized tools like `get_pokemon` or `list_types`. It handles all 1000+ species, making complex data joining immediate and conversational. ## Overview - **Category:** data-management - **Price:** Free - **Tags:** gaming-data, rest-api, metadata-lookup, species-data, open-data, encyclopedia ## Description **PokéAPI gives your AI client direct access to every piece of Pokémon data.** Forget reading massive wikis or running through clunky web forms; you just ask your agent what you need, and it handles the lookup instantly using specialized tools. It covers stats, moves, types, abilities, evolution lines—the whole nine yards. **To check a specific Pokémon's details**, you use `get_pokemon` to pull up comprehensive data on any species by name or ID. If you need more depth, `get_pokedex` gives you info about a specific Pokédex entry or regional group, and `get_pokemon_species` drills down into its classification data. You can also get the full picture of a Pokémon's physical traits using `get_pokemon`, which provides stats, height, weight, types, and abilities. **Understanding combat mechanics is straightforward.** The system calculates damage multipliers—super effective, resisted, or neutral—by calling `get_type` with any two elemental types. When planning battle strategies, you don't have to guess; use `get_move` to see a move's power, accuracy, and effects, and check out `get_item` for detailed info on anything held, like Poké Balls or berries. **You can map the whole life cycle.** If you need to know how a Pokémon progresses, `get_evolution_chain` maps out its entire family tree, detailing every step and what conditions—like specific items or friendship levels—are required for it to evolve. For passive traits, `get_ability` retrieves detailed information about any given ability. **The agent lets you browse everything.** To get an overview of the game world's structure, use tools like `list_types` to see all eighteen elemental types, or `list_abilities` for every known passive trait. You can scope your search by calling `list_generations` to list established lore generations, and `list_regions` if you need to know about geographical areas in the Pokémon world. If you're tracking items, `list_items` gives a complete roster of everything that can be held. For moves, `list_moves` provides every available action, while `list_berries` lists all berry types and their associated effects. **Diving deep into context.** You can get specific details about global groups using `list_pokedexes`, or you can pull regional information using `get_region` if the location matters. For a broader view of the game's scope, `list_pokemon` lets your agent browse through the full catalog of Pokémon names. Furthermore, `get_generation` retrieves details for any specific generation's data set. **The system connects these pieces.** Your AI client doesn't just read; it runs complex queries. Asking 'What happens when a Fire type hits Grass?' invokes `get_type`. Needing to know Pikachu’s base stats and types sends the request to `get_pokemon`. If you want to see all possible passive traits, you run `list_abilities` and then use `get_ability` on the result. The agent handles this data joining—it takes your natural language question and spits out clean JSON that it can synthesize into a readable answer for you. You'll never waste time cross-referencing multiple databases; just ask your agent. ## Tools ### get_ability Retrieves detailed information about a specific Pokémon ability. ### get_berry Gets detailed data and effects for a specified type of berry item. ### get_evolution_chain Maps out the entire evolutionary line for a Pokémon, listing all conditions needed to progress. ### get_generation Retrieves details pertaining to a specific generation of Pokémon data. ### get_item Fetches detailed information, uses, and costs for any held item. ### get_move Provides comprehensive stats on a specific move, including power, accuracy, and effects. ### get_pokedex Gets detailed information about a specific Pokédex entry or region group. ### get_pokemon Retrieves detailed stats, types, abilities, height, and weight for any Pokémon by name or ID. ### get_region Retrieves details about a geographical region in the Pokémon world. ### get_pokemon_species Gets specific data related to a Pokémon's species classification. ### get_type Checks damage relations and type effectiveness between elemental types. ### list_abilities Lists all known passive abilities that a Pokémon can have. ### list_berries Provides a list of every berry type and its associated effects. ### list_generations Lists all established generations within the Pokémon lore. ### list_items Provides a comprehensive list of every held item in the game world. ### list_moves Lists all known moves available to Pokémon. ### list_pokedexes Lists all recognized Pokédex entries and their associated regions. ### list_pokemon Browses through the full catalog of Pokémon names using pagination controls. ### list_regions Lists all geographical regions and their associated locations in the game. ### list_types Lists all 18 distinct elemental types recognized by Pokémon. ## Prompt Examples **Prompt:** ``` Show me everything about Pikachu. ``` **Response:** ``` Pikachu (#025) is an Electric-type Pokémon. Height: 0.4m, Weight: 6.0kg. Base stats: HP 35, Attack 55, Defense 40, Sp. Atk 50, Sp. Def 50, Speed 90. Abilities: Static (Lightning Rod is hidden). It evolves from Pichu and into Raichu. ``` **Prompt:** ``` What types are strong against Fire? ``` **Response:** ``` Fire-type Pokémon are weak to Water, Ground, and Rock types (take 2x damage). They resist Fire, Grass, Ice, Bug, Steel, and Fairy (take 0.5x damage). Fire moves are super effective against Grass, Ice, Bug, and Steel. ``` **Prompt:** ``` What's the evolution chain for Eevee? ``` **Response:** ``` Eevee has 8 possible evolutions! Vaporeon (Water Stone), Jolteon (Thunder Stone), Flareon (Fire Stone), Espeon (high friendship during day), Umbreon (high friendship at night), Leafeon (near Moss Rock), Glaceon (near Ice Rock), and Sylveon (high affection with Fairy-type move). ``` ## Capabilities ### Lookup Specific Pokémon Details Retrieves comprehensive stats, abilities, and physical traits for any named or ID-based Pokémon. ### Analyze Type Effectiveness Calculates damage multipliers (super effective, resisted, neutral) between any two specified elemental types. ### Map Evolution Lines Builds and retrieves a complete, step-by-step family tree for a Pokémon species, including required items or conditions. ### Query Item and Move Metadata Provides granular details on held items (Poké Balls, berries) and specific moves (power, accuracy, PP). ### Browse Global Catalogs Lists all major entities—types, abilities, regions, or generations—allowing the agent to scope a search. ## Use Cases ### Checking type matchups for a team build A designer needs to know if their proposed team works. They ask the agent, 'What is my weakness against Ground?' The agent runs `get_type` and immediately reports that Water, Grass, and Fighting types are needed to mitigate damage. ### Drafting lore for a new Pokémon type A technical writer needs rules for a 'Crystal' type. They ask the agent to list all existing types using `list_types`, see the gaps, and then use `get_type` iteratively with their proposed Crystal type against known elemental types. ### Identifying an unknown evolutionary requirement A player asks about a rare evolution. The agent runs `get_evolution_chain` on the target Pokémon, which instantly reveals that it requires high friendship *and* a specific item like a Thunder Stone. ### Cataloging all available combat options An editor needs to write an exhaustive guide. They use `list_moves` and then iterate through the results, calling `get_move` on each one to gather full metadata for their article. ## Benefits - Get instant battle data. Instead of cross-referencing wikis, simply ask the agent to use `get_type` to determine if Fire is super effective against Grass. The result is immediate damage math. - Build complex timelines effortlessly. Use `get_evolution_chain` to map out an entire family tree (like Eevee's 8 paths) and list every required item or condition in one query. - Deep-dive into mechanics without guesswork. Need a move’s exact stats? Calling `get_move` gives you the raw power, accuracy, and PP metadata for any attack immediately. - Never forget an item's function again. Running `list_items` or `get_item` instantly shows the effect of Poké Balls or berries, eliminating manual database checks. - Structured browsing at scale. If you need to see what regions exist across different eras, use `list_regions` and then combine that data with specific calls like `get_pokedex`. ## How It Works The bottom line is: your AI client handles the API calls; you just ask questions in English. 1. First, the AI client parses your request and determines which specific data point you need (e.g., 'I need Pikachu's stats'). 2. The agent executes the corresponding tool call—for instance, calling `get_pokemon` with the identifier. The server returns raw JSON data. 3. Your agent processes that structured JSON output, filtering and formatting it into a natural language summary for you. ## Frequently Asked Questions **How do I check damage matchups with the PokéAPI MCP Server?** Use the `get_type` tool. You pass two types to this tool, and it returns the specific damage multiplier (e.g., 2x, 0.5x) for the matchup. It's the fastest way to plan a battle. **Which tool should I use to see Pikachu’s stats?** You need `get_pokemon`. This tool takes either the Pokémon name or its ID and returns comprehensive data including HP, Attack, Defense, etc. **Can I find out how a Pokémon evolves using get_evolution_chain?** Yes. Running `get_evolution_chain` provides the full sequence of evolution steps, detailing required items (like a Water Stone) or conditions needed for each stage. **What is list_types used for in this server?** `list_types` gives you a clean array of all 18 elemental types. This is useful when your query needs to reference every type, like listing weaknesses across the board. **Where do I get detailed information on held items?** Use `get_item`. You can pass in an item name (like 'Berry') and it returns a full description of its effects, cost, and usage notes. **When I use get_pokemon, do I need an API key or authentication credentials?** Nope, you don't. The PokéAPI server is free and open source, so you just connect your AI client directly. No keys or setup are required for basic access. **How does get_pokemon handle searching for a Pokémon? Can I use its name or ID?** It handles both. You can pass either the Pokémon's common name or its numeric ID to the tool. This makes it flexible whether your agent knows the creature's number or just its name. **If I need to retrieve the entire catalog of creatures using list_pokemon, how should I manage pagination?** You use limit and offset parameters within the tool call. This mechanism lets your AI client browse through all 1000+ Pokémon entries in manageable batches. **Do I need a Pokémon Trainer Club account or API key?** No! PokéAPI is a completely free, open-source project. No authentication, no rate limits, no registration required. **Can I look up Pokémon by name or ID number?** Yes! Both work perfectly. Use `get_pokemon` with either the Pokédex number (e.g., "25") or the name (e.g., "pikachu"). **Can I see a Pokémon's full evolution chain?** Yes! Use `get_pokemon_species` to get the species data which includes the evolution chain ID, then use `get_evolution_chain` to see the full family tree with all evolution conditions and requirements.