PoGo API - A small collection of Pokemon Go tools and API's

PoGoAPI Documentation

This page holds the the documentation about all the API's we offer holding Pokemon Go Data.

If you are missing some data you want feel free to contact me on Twitter.

Using these API's

It is recommended to locally cache these files so you can store them on your own server and use them as needed. To help facilitate this a hash API is provided, which gives the current hashes of all API's available. By downloading the current hashes you can compare them against the files you have stored. Then if the hashes are different you know you need to update the file.

This should reduce the traffic requirements on both my and your website and make updating easier.

GET /api/v1/api_hashes.json

Returns a json dict with the keys being the api filename and the values being an array containing api_filename, full_path, hash_md5, hash_sha1, hash_sha256.

Example data

{
    "alolan_pokemon.json": {
        "api_filename": "alolan_pokemon.json",
        "full_path": "/api/v1/alolan_pokemon.json",
        "hash_md5": "355f4ec183f1f519d9cae8e16013dcf4",
        "hash_sha1": "0bb393f6819825afa0ae89e38c1c57e2805371f3",
        "hash_sha256": "d3ea3002c9bbbd4a955bec49352a36c8ed5c6c62cfe8b3f71acfd2083a828b33"
    }, ...
}

GET /api/v1/pokemon_names.json

Returns a json dict with the keys being the pokemon ID, the values are an array containing the pokemon name and ID.

Example data

{
    1: {
        id: 1,
        name: "Bulbasaur"
    },
    2: {
        id: 2,
        name: "Ivysaur"
    },
    3: {
        id: 3,
        name: "Venusaur"
    }, ...
}

GET /api/v1/released_pokemon.json

Currently in Pokemon Go the majority of Pokemon have been released from the first three generations of Pokemon games. This API lets you get the full list of Pokemon that are currently released.

Returns a json dict with the keys being the pokemon ID, the values are an array containing the pokemon name and ID.

Example data

{
    1: {
        id: 1,
        name: "Bulbasaur"
    },
    2: {
        id: 2,
        name: "Ivysaur"
    },
    3: {
        id: 3,
        name: "Venusaur"
    }, ...
}

GET /api/v1/nesting_pokemon.json

Only specific Pokemon will nest and this API lets you get the name and ID of all Pokemon known to currently nest.

Returns a JSON dict with the keys being the Pokemon ID, the values are an array containing the pokemon name and ID.

Example data

{
    1: {
        id: 1,
        name: "Bulbasaur"
    },
    4: {
        id: 4,
        name: "Charmander"
    },
    7: {
        id: 7,
        name: "Squirtle"
    }, ...
}

GET /api/v1/shiny_pokemon.json

Returns a JSON dict with the keys being the Pokemon ID, the values are an array containing the Pokemon name, ID, and how that shiny can be found.

There are four main keys determining how the shiny can be found:

• found_wild - True if the shiny Pokemon is found in the wild
• found_raid - True if the shiny Pokemon was once in, or currently is in raids as a shiny possibility
• found_egg - True if the shiny Pokemon can be hatched from an egg as a shiny
• found_evolution - True if the Pokemon can be evolved from another shiny Pokemon
• found_research - True if the Pokemon can be found as a shiny from a research task
• found_photobomb - True if the Pokemon could be shiny if it appears in a photobomb (It does not mean the pokemon can photobomb)
• alolan_shiny - True if the Pokemon can be found as shiny in its alolan form, not present for non alolan Pokemon

Example data

{
    1: {
        name: "Bulbasaur",
        found_wild: true,
        found_raid: false,
        found_egg: false,
        found_evolution: false,
        id: 1
    },
    2: {
        name: "Ivysaur",
        found_wild: false,
        found_raid: false,
        found_egg: false,
        found_evolution: true,
        id: 2
    }, ...
}

GET /api/v1/raid_exclusive_pokemon.json

Returns a JSON dict with the keys being the Pokemon ID, the values are an array containing the Pokemon name, ID, and and level raid they can be found in.

Currently all raid exclusive pokemon are tied to a specific raid level. In the future the API might need to change if this changes.

Example data

{
    303: {
        raid_level: 2,
        id: 303,
        name: "Mawile"
    },
    359: {
        raid_level: 4,
        id: 359,
        name: "Absol"
    }
}

GET /api/v1/alolan_pokemon.json

In Generation 7 of the Pokemon video games Alolan Pokemon were released. These are pokemon who canonically evolved in a different area so are subtly different from the standard Pokemon. These all look different and have different typing to classical pokemon. This API allows you to get a list of currently released alolan Pokemon.

Returns a JSON dict with the keys being the Pokemon ID, the values are an array containing the pokemon name and ID.

Example data

{
    19: {
        id: 19,
        name: "Rattata"
    },
    20: {
        id: 20,
        name: "Raticate"
    },
    26: {
        id: 26,
        name: "Raichu"
    }, ...
}

GET /api/v1/possible_ditto_pokemon.json

Ditto is a Pokemon that can transform into any Pokemon. In the wild you find him by catching a Pokemon which then transforms into Ditto. You cant tell which Pokemon might turn into a Ditto however if someone has caught a Ditto it will be a Ditto for everyone. This API allows you to get the list of Pokemon which are potentially a Ditto.

Returns a JSON dict with the keys being the Pokemon ID, the values are an array containing the pokemon name and ID.

Example data

{
    41: {
        "id": 41,
        "name": "Zubat"
    },
    "16": {
        "id": 16,
        "name": "Pidgey"
    },
    "19": {
        "id": 19,
        "name": "Rattata"
    }, ...
}

GET /api/v1/pokemon_stats.json

Each Pokemon has three base stats, attack, defense and stamina which determine how innately strong it is in each of these areas. These effect how much HP and damage each move can do along with its level and the typing of the moves.

Returns a JSON array where each element is a dict containing the pokemon name, ID, base stamina, base attack, and base defense.

[
    {
        base_stamina: "90",
        base_defense: "118",
        base_attack: "118",
        name: "Bulbasaur",
        id: 1
    },
    {
        base_stamina: "120",
        base_defense: "151",
        base_attack: "151",
        name: "Ivysaur",
        id: 2
    },
    {
        base_stamina: "160",
        base_defense: "198",
        base_attack: "198",
        name: "Venusaur",
        id: 3
    },..
]

GET /api/v1/fast_moves.json

Each Pokemon has a fast and charged move. This API allows you to download the full list of fast moves in the current Pokemon Go game master.

Returns a JSON array where each element is a dict containing the stamina_loss_scaler, name, power, duration, energy_delta and type.

[
    {
        "stamina_loss_scaler": "0.01",
        "name": "Fury Cutter",
        "power": 3,
        "duration": 400,
        "energy_delta": 6,
        "type": "Bug"
    }, {
        "stamina_loss_scaler": "0.01",
        "name": "Bug Bite",
        "power": 5,
        "duration": 500,
        "energy_delta": 6,
        "type": "Bug"
    }, {
        "stamina_loss_scaler": "0.01",
        "name": "Bite",
        "power": 6,
        "duration": 500,
        "energy_delta": 4,
        "type": "Dark"
    }, ...
]

GET /api/v1/charged_moves.json

Each Pokemon has a fast and charged move. This API allows you to download the full list of charged moves in the current Pokemon Go game master.

Returns a JSON array where each element is a dict containing the stamina_loss_scaler, name, power, duration, critical_chance (optional), energy_delta, heal_scalar (optional) and type.

[
    {
        "stamina_loss_scaler": "0.06",
        "name": "Wrap",
        "power": 60,
        "duration": 2900,
        "critical_chance": "0.05",
        "energy_delta": -33,
        "type": "Normal"
    }, {
        "stamina_loss_scaler": "0.15",
        "name": "Hyper Beam",
        "power": 150,
        "duration": 3800,
        "critical_chance": "0.05",
        "energy_delta": -100,
        "type": "Normal"
    }, {
        "stamina_loss_scaler": "0.08",
        "name": "Dark Pulse",
        "power": 80,
        "duration": 3000,
        "critical_chance": "0.05",
        "energy_delta": -50,
        "type": "Dark"
    }, ...
]

GET /api/v1/pokemon_max_cp.json

Each Pokemon has a maximum CP that it may achieve if it is a perfect pokemon (with 15 attack, stamina, and defense) and is level 40. This API returns the maximum CP for each Pokemon.

Returns a JSON array where each element is a dict containing the pokemon name, ID, and maximum CP.

[
    {
        name: "Bulbasaur",
        max_cp: 981,
        id: 1
    },
    {
        name: "Ivysaur",
        max_cp: 1552,
        id: 2
    },
    {
        name: "Venusaur",
        max_cp: 2568,
        id: 3
    }, ...
]

GET /api/v1/pokemon_buddy_distances.json

When you make a Pokemon your buddy after a certain distance walked with them you will get 1 candy from them. This distance depends on the specific Pokemon. The current buddy distances are 1, 3, 5, and 20 kilometres distance.

Returns a JSON object where each key is the distance needed to gain a candy and the value is a list containing multiple objects holding distance, Pokemon ID, Pokemon name and optionally the form.

{
    "1": [
        {
            "distance": 1,
            "pokemon_id": 10,
            "pokemon_name": "Caterpie"
        },
        {
            "distance": 1,
            "pokemon_id": 11,
            "pokemon_name": "Metapod"
        },
        {
            "distance": 1,
            "pokemon_id": 12,
            "pokemon_name": "Butterfree"
        }, ...
    ], ...
}

GET /api/v1/pokemon_candy_to_evolve.json

For all Pokemon that evolve there will be a specific candy requirement. This API groups the evolvable Pokemon into the specific candy requirements for each.

Returns a JSON object where each key is the amount of candy needed to evolve and the value is a list containing multiple objects holding candy needed to evolve, Pokemon ID, Pokemon name and optionally the form.

{
    "100": [
        {
            "candy_required": 100,
            "pokemon_id": 2,
            "pokemon_name": "Ivysaur"
        },
        {
            "candy_required": 100,
            "pokemon_id": 5,
            "pokemon_name": "Charmeleon"
        },
        {
            "candy_required": 100,
            "pokemon_id": 8,
            "pokemon_name": "Wartortle"
        }, ...
    ],...
}

GET /api/v1/pokemon_encounter_data.json

When encountering a Pokemon there are a number of metrics that influence the catch rate, and what it does during the encounter. This API groups all the information that influences an encounter together.

Returns a JSON array where each element is a dict containing attack_probability, base_capture_rate, base_flee_rate, dodge_probability, max_pokemon_action_frequency, min_pokemon_action_frequency, Pokemon ID, Pokemon name and optionally the form.

NOTE: base_capture_rate and base_flee_rate are both hardcoded to -1 because Niantic removed this data. This was done after the community kept realising that the rates were not properly boosted for various events.

The fields attack_probability and dodge_probability are a value from 0 to 1. 0 represents 0% chance of it occurring each turn and 1 represents 100% chance. The fields max_pokemon_action_frequency, and min_pokemon_action_frequency are in seconds representing the maximum and minimum amount of time between an action.

[
    {
        "attack_probability": 0.1,
        "base_capture_rate": 0.2,
        "base_flee_rate": 0.1,
        "dodge_probability": 0.15,
        "max_pokemon_action_frequency": 1.6,
        "min_pokemon_action_frequency": 0.2,
        "pokemon_id": 1,
        "pokemon_name": "Bulbasaur"
    },
    {
        "attack_probability": 0.1,
        "base_capture_rate": 0.1,
        "base_flee_rate": 0.07,
        "dodge_probability": 0.15,
        "max_pokemon_action_frequency": 1.6,
        "min_pokemon_action_frequency": 0.2,
        "pokemon_id": 2,
        "pokemon_name": "Ivysaur"
    }, ...
]

GET /api/v1/pokemon_types.json

All Pokemon have either one or two types, these types affect the strength of moves and weaknesses it has to opponents moves. This API lists the types of each Pokemon.

Returns a JSON array where each element is a dict containing type (an array of one or two items), Pokemon ID, Pokemon name and optionally the form.

[
    {
        "pokemon_id": 1,
        "pokemon_name": "Bulbasaur",
        "type": [
            "Grass",
            "Poison"
        ]
    },
    {
        "pokemon_id": 2,
        "pokemon_name": "Ivysaur",
        "type": [
            "Grass",
            "Poison"
        ]
    },
    {
        "pokemon_id": 3,
        "pokemon_name": "Venusaur",
        "type": [
            "Grass",
            "Poison"
        ]
    }, ...
]

GET /api/v1/weather_boosts.json

During different weather certain types will be boosted. When they are boosted Pokemon of the boosted types will be found at a higher level, and moves of that type will be more powerful. This API lists what each weather type boosts.

Returns a JSON dict where each key is the weather type and the value is an array of boosted types.

{
    Clear: [
        "Grass",
        "Ground",
        "Fire"
    ],
    Cloudy: [
        "Fairy",
        "Fighting",
        "Poison"
    ], ...
}

GET /api/v1/type_effectiveness.json

When a Pokemon attacks, a multiplier is applied based on the attacker and defender types. This type effectiveness is very important to help deal the most damage as possible in raids and pvp. This API details how each type multiplier is applied.

Returns a JSON dict where each key is the attacking type and the value is a dict of defender types and the damage multiplier.

{
    "Bug": {
        "Bug": "1",
        "Dark": "1.6",
        "Dragon": "1",
        "Electric": "1",
        "Fairy": "0.625",
        "Fighting": "0.625",
        "Fire": "0.625",
        "Flying": "0.625",
        "Ghost": "0.625",
        "Grass": "1.6",
        "Ground": "1",
        "Ice": "1",
        "Normal": "1",
        "Poison": "0.625",
        "Psychic": "1.6",
        "Rock": "1",
        "Steel": "0.625",
        "Water": "1"
    }, ...
}

GET /api/v1/pokemon_rarity.json

Pokemon are split up into 3 rarity types. These are Standard, Legendary, and Mythic. Typically Legendary and Mythic Pokemon have different trading rules along with a much higher buddy walking distance. This API details how what rarity ranking Pokemon Go places each Pokemon in.

Returns a JSON dict where each key is the rarity type and the value is a list of dicts containing the details of Pokemon in that rarity group. Each Pokemon dict has the pokemon_id, pokemon_name and rarity inside it for ease of processing.

{
    "Legendary": [
        {
            "pokemon_id": 144,
            "pokemon_name": "Articuno",
            "rarity": "Legendary"
        },
        {
            "pokemon_id": 145,
            "pokemon_name": "Zapdos",
            "rarity": "Legendary"
        },
        {
            "pokemon_id": 146,
            "pokemon_name": "Moltres",
            "rarity": "Legendary"
        }, ...
    ], ...
}

GET /api/v1/pokemon_powerup_requirements.json

To power up a pokemon you need to pay some stardust and candy. There are two types of candy, XL and standard candy. Standard candy is used to power Pokemon from level 1 to 40. XL candy is used to then power a Pokemon from level 40 up to a maximum level of 50. This API details how much it will cost to power up a Pokemon each level.

Returns a JSON dict where each key is the current level and the value is a dictionary containing the cost of powering up a Pokemon at that level. Each powerup dict contains the candy to upgrade, the XL candy to upgrade, the stardust to upgrade, the current level and the next level.

{
    "1": {
        "candy_to_upgrade": 1,
        "current_level": 1,
        "level_after_powering": 1.5,
        "stardust_to_upgrade": 200,
        "xl_candy_to_upgrade": 0
    },
    "1.5": {
        "candy_to_upgrade": 1,
        "current_level": 1.5,
        "level_after_powering": 2.0,
        "stardust_to_upgrade": 200,
        "xl_candy_to_upgrade": 0
    },
    "2": {
        "candy_to_upgrade": 1,
        "current_level": 2,
        "level_after_powering": 2.5,
        "stardust_to_upgrade": 200,
        "xl_candy_to_upgrade": 0
    }, ...
}

GET /api/v1/pokemon_genders.json

Each Pokemon either has a gender of male or female, or is classified as genderless. This is important for some Pokemon who have gender specific evolutions. For example only a female Combee will evolve.

For each Pokemon there is percentage chance of any gender. For example some Pokemon are exclusively male or female and some are skewed towards one gender. This API details the gender breakdown for each Pokemon.

Returns a JSON dict where each key is the name of the gender ratio and the value is a list of Pokemon and their gender percentages. This dictionary holds the Pokemon ID, Pokemon name, and their gender percentages under the gender key.

The gender key is a dictionary which has three possible keys, female_percent, male_percent, genderless_percent. These values are a value from 0 to 1 and are not percentages but are kept named as such as this is what the game master calls it. 1 represents the Pokemon is entirely of one gender. The actual percentage may be obtained by multiplying the value by 100.

{
    "0M_1F": [
        {
            "gender": {
                "female_percent": "1"
            },
            "pokemon_id": 29,
            "pokemon_name": "Nidoran\u2640"
        },
        {
            "gender": {
                "female_percent": "1"
            },
            "pokemon_id": 30,
            "pokemon_name": "Nidorina"
        }, ...
    }, ...
}

GET /api/v1/player_xp_requirements.json

For each Pokemon Go level you are required to reach a specific amount of cumulative xp. This API details the cumulative xp requirement for each level.

Returns a JSON dict where each key is the level and the value is the xp required for the keys level.

{
    "1": 0,
    "2": 1000,
    "3": 3000,
    "4": 6000,
    "5": 10000,
    "6": 15000,
    "7": 21000,
    "8": 28000, ...
}

GET /api/v1/pokemon_generations.json

Each Pokemon has an associated generation that it was originally released in. Currently Niantic are progressing through the generations releasing Pokemon. This API lists each Pokemon and the generation it was released in.

Returns a JSON dict where each key is the generation name and the value is a list of Pokemon that are from that generation. Each Pokemon entry has its name, Pokemon ID, and generation number.

{
    "Generation 1": [
        {
            "generation_number": 1,
            "id": 1,
            "name": "Bulbasaur"
        },
        {
            "generation_number": 1,
            "id": 2,
            "name": "Ivysaur"
        }, ...
    ], ...
}

GET /api/v1/shadow_pokemon.json

Currently there are only a few Pokemon released as possible shadow Pokemon. These are obtained by finding a rocket stop and fighting the grunt at it. Once you defeat the grunt you are given the opportunity to catch one of their Pokemon they leave behind.

This API shows the currently available shadow Pokemon.

Returns a json dict with the keys being the pokemon ID, the values are an array containing the pokemon name and ID.

Example data

{
    1: {
        id: 1,
        name: "Bulbasaur"
    },
    2: {
        id: 2,
        name: "Ivysaur"
    },
    3: {
        id: 3,
        name: "Venusaur"
    }, ...
}

GET /api/v1/pokemon_forms.json

Some Pokemon are available in multiple different forms which may have different stats and abilities. The majority of Pokemon will always be available in the "Normal" form which is typically the most common. A small number of Pokemon will have no "Normal" form which may occur when their forms are unique to that Pokemon.

Common forms are as follows:

• Normal - The standard Pokemon form
• Alola - A form of Pokemon from the Alola region
• Shadow - Pokemon which have been caught from Team Go Rocket encounters
• Purified - Pokemon that have been purified using stardust after being caught as a Shadow Pokemon from Team Go Rocket

This API returns all the currently possible Pokemon forms in the game master.

Returns a list of possible Pokemon forms in alphabetical order.

Example data

[
    "A",
    "Alola",
    "Altered",
    "Aria",
    "Attack",
    "Autumn",
    "Black",
    "Blue_striped",
    ...
]

GET /api/v1/current_pokemon_moves.json

When a Pokemon is caught, evolved, or hatched the moves are randomly chosen from a pool of potential moves. These moves change from time to time as moves are added and removed from the pool of moves. Whenever a TM is used, a random move from the list of potential moves is chosen and the Pokemon will learn it in place of an old move.

During community days and other events some Pokemon will be given special moves for short period of times. These moves will be added to the pool so the Pokemon can get them but are removed after the event finishes. These are called Legacy moves will typically be available by using an elite TM. These moves are noted in the elite_charged_moves and elite_fast_moves arrays. Currently an Elite TM can only be used to learn legacy charged moves.

This API returns all moves that Pokemon can currently learn via catching, evolving, hatching, or using TM's.

Returns a JSON array where each element is a dict containing Pokemon ID, Pokemon name, an array of charged moves, an array of fast moves, an array of charged moves learnable from an elite TM, an array of fast legacy fast moves, and optionally the form.

Example data

[
    {
        "charged_moves": [
            "Sludge Bomb",
            "Seed Bomb",
            "Power Whip"
        ],
        "elite_charged_moves": [],
        "elite_fast_moves": [],
        "fast_moves": [
            "Vine Whip",
            "Tackle"
        ],
        "form": "Normal",
        "pokemon_id": 1,
        "pokemon_name": "Bulbasaur"
    },
    {
        "charged_moves": [
            "Sludge Bomb",
            "Solar Beam",
            "Power Whip"
        ],
        "elite_charged_moves": [],
        "elite_fast_moves": [],
        "fast_moves": [
            "Razor Leaf",
            "Vine Whip"
        ],
        "form": "Normal",
        "pokemon_id": 2,
        "pokemon_name": "Ivysaur"
    },
    {
        "charged_moves": [
            "Sludge Bomb",
            "Petal Blizzard",
            "Solar Beam"
        ],
        "elite_charged_moves": [
            "Frenzy Plant"
        ],
        "elite_fast_moves": [],
        "fast_moves": [
            "Razor Leaf",
            "Vine Whip"
        ],
        "form": "Normal",
        "pokemon_id": 3,
        "pokemon_name": "Venusaur"
    }, ...
]

GET /api/v1/pvp_exclusive_pokemon.json

Some Pokemon and their evolutions are only available in PVP. Currently to get these Pokemon you need to win a number of battles in the PVP league with a standard or premium battle pass.

When using a standard battle pass you will need to win four battles. However if you use a premium pass you will only need to win two to get a chance at a PVP exclusive Pokemon.

This API returns all Pokemon that are exclusively available from PVP.

Example data

[
    {
        "id": 627,
        "name": "Rufflet"
    },
    {
        "id": 560,
        "name": "Scrafty"
    }
]

GET /api/v1/galarian_pokemon.json

In Generation 8 of the Pokemon video games Galarian Pokemon were released. These are pokemon who canonically evolved in a different area so are subtly different from the standard Pokemon. These all look different and have different typing to classical pokemon. This API allows you to get a list of currently released Galarian Pokemon.

Returns a JSON dict with the keys being the Pokemon ID, the values are an array containing the pokemon name and ID.

Example data

{
    "110": {
        "id": 110,
        "name": "Weezing"
    },
    "263": {
        "id": 263,
        "name": "Zigzagoon"
    },
    "264": {
        "id": 264,
        "name": "Linoone"
    },
    "52": {
        "id": 52,
        "name": "Meowth"
    }, ...
}

GET /api/v1/cp_multiplier.json

For each level and half level the Combat Points of a Pokemon is defined by its stats, level and a hidden multiplier. This multiplier is defined in the GAME_MASTER for every level up to 45. Half levels up to 40 are calculated from observing various CP values. Half levels between 40 and 45 are roughly calculated using interpolation and may not be entirely correct.

Returns a JSON array of objects, the values of the array are an object with the keys level and multiplier.

Example data

[
    {
        "level": 1,
        "multiplier": 0.09399999678134918
    },
    {
        "level": 1.5,
        "multiplier": 0.1351374313235283
    },
    {
        "level": 2.0,
        "multiplier": 0.16639786958694458
    }, ...
]

GET /api/v1/community_days.json

Typically each month Niantic run a Pokemon Go Community day which is designed to encourage trainers to come and play Pokemon Go together. These days typically highlight one or more Pokemon which will have boosted spawn rates during the event. These boosted Pokemon also normally have a boosted shiny rate.

In addition to boosted spawn rates a number of Pokemon will have special moves which will only be available to obtain during the event. There is also typically additional bonuses such as boosted XP or stardust for catches.

Returns a JSON array of objects, the objects have the following keys.

• bonuses - An array of bonuses. These may include:
  • Double XP
  • Triple Catch Stardust
  • Triple Catch XP
  • Quadruple Incubator effectiveness
  • Double Catch XP
  • Double Catch Stardust
  • Double Incubator effectiveness
• boosted_pokemon - A list of Pokemon names that are have boosted shiny and spawn rates.
• community_day_number - The number of the community day starting from 1.
• end_date - Date that the event ends on. This is the same as start_date if the event is only a single day.
• event_moves - A list of objects that detail the special moves which can be obtained during the event and what Pokemon can learn them. The keys of this object are:
  • move - Name of the move that can be learnt
  • move_type - Either "charged" or "fast" depending whether the move is a charged or fast move.
  • pokemon - Name of the Pokemon that learns the move.
• start_date - Date that the event starts on. This is the same as end_date if the event is only a single day.

Example data

[
    {
        "bonuses": [
            "Double XP"
        ],
        "boosted_pokemon": [
            "Pikachu"
        ],
        "community_day_number": 1,
        "end_date": "2018-01-20",
        "event_moves": [
            {
                "move": "Surf",
                "move_type": "charged",
                "pokemon": "Pikachu"
            }
        ],
        "start_date": "2018-01-20"
    }, ...
]

GET /api/v1/pokemon_evolutions.json

Some Pokemon can evolve into a stronger form by feeding them candy or meeting certain conditions. Once these conditions have been met you can press the "evolve" button to transform them to the next form.

If multiple evolutions meet the requirements and they have the same priority (or it is not set) the evolution will be randomly chosen.

This API lists all the Pokemon that can evolve, what they can evolve into, and the requirements for their evolution.

Returns a JSON array of objects, the objects have the following keys.

• pokemon_id - ID of the Pokemon that evolves
• pokemon_name - Name of the Pokemon that evolves
• form - Only present if the Pokemon has multiple forms
• evolutions - An array of objects detailing what Pokemon this can evolve into. Each object has the following keys:
  • candy_required - The amount of candy to evolve this Pokemon with standard means
  • item_required - If the Pokemon requires an item to evolve this will be the name of the item
  • lure_required - If the Pokemon requires a lure to evolve this will be the name of the lure
  • no_candy_cost_if_traded - This will be set to true if the evolution will cost no candy after trading
  • priority - If a priority is set then the evolution with the highest priority will be chosen above those with a lower priority when multiple evolution criteria are met
  • only_evolves_in_daytime - Set to true if the Pokemon will only evolve in the daytime
  • only_evolves_in_nighttime - Set to true if the Pokemon will only evolve at night time
  • must_be_buddy_to_evolve - Set if this evolution can only occur if they are your buddy
  • buddy_distance_required - Set if this Pokemon must have been walked a specific amount of distance to evolve
  • gender_required - Set to Male/Female if a specific gender is required for the evolution

Example data

[
    {
        "pokemon_id": 133,
        "pokemon_name": "Eevee",
        "evolutions": [
            {
                "candy_required": 25,
                "pokemon_id": 134,
                "pokemon_name": "Vaporeon"
            },
            {
                "candy_required": 25,
                "pokemon_id": 135,
                "pokemon_name": "Jolteon"
            },
            {
                "candy_required": 25,
                "pokemon_id": 136,
                "pokemon_name": "Flareon"
            },
            {
                "buddy_distance_required": 10.0,
                "candy_required": 25,
                "must_be_buddy_to_evolve": true,
                "only_evolves_in_daytime": true,
                "pokemon_id": 196,
                "pokemon_name": "Espeon",
                "priority": 100
            },
            {
                "buddy_distance_required": 10.0,
                "candy_required": 25,
                "must_be_buddy_to_evolve": true,
                "only_evolves_in_nighttime": true,
                "pokemon_id": 197,
                "pokemon_name": "Umbreon",
                "priority": 100
            },
            {
                "candy_required": 25,
                "lure_required": "Mossy Lure Module",
                "pokemon_id": 470,
                "pokemon_name": "Leafeon",
                "priority": 200
            },
            {
                "candy_required": 25,
                "lure_required": "Glacial Lure Module",
                "pokemon_id": 471,
                "pokemon_name": "Glaceon",
                "priority": 200
            }
        ]
    }, ...
]

GET /api/v1/raid_bosses.json

During the day Raid Boss eggs will hatch at gyms. These eggs will be ranked according to their tier, 1 to 5. The average strength of each tier is:

• Tier 1 - Easy Solo
• Tier 2 - Medium Solo
• Tier 3 - Hard Solo (may be impossible and need more)
• Tier 4 - Hard Duo (may be impossible and need more)
• Tier 5 - Hard Duo to Hard Quint (Tier 5 raid bosses strength vary wildly)
• Mega - Mega Evolutions (raid boss strength unknown currently)

Some Tier 5 bosses are artificially made stronger and are given the stats of a "Tier 6". These have typically been very weak Tier 5 bosses that needed to be made a bit stronger. These Tier 6 bosses will appear as a Tier 5 but will have the stats of a Tier 6. For simulation purposes it is important to know the distinction between a Tier 5 and 6 so the bosses rankings here are from Tier 1 to Tier 6 although in the wild you will only see Tier 1 to Tier 5.

Eggs will appear at gyms during the day and will be coloured according to its tier. Once the timer has expired the egg will "hatch" and display the boss that was inside the egg. This boss will then be able to be challenged during the entire time, until either you beat him or you run out of time. We know that bosses are chosen when the egg appears so when bosses change you will only see new bosses from eggs appearing after the changeover.

Once the boss has hatched and during the time a boss is occupying the gym you are not able to knock out Pokemon from the gym or add Pokemon to it if it is your teams gym.

Returns a JSON dict with two keys, current and previous. Each of these hold dicts which have keys of 1 to 6 and the values are an array. Each array holds a dict with the following keys:

• boosted_weather - Array of weather types the boss will be boosted in. In these types it will be stronger to fight and be level 25 when caught.
• form - Form of the boss
• id - Pokemon ID of the boss
• max_boosted_cp - The combat power of a 15,15,15 100% IV boss caught when it is fought in boosted weather (level 25)
• max_unboosted_cp - The combat power of a 15,15,15 100% IV boss caught when it is fought in unboosted weather (level 20)
• min_boosted_cp - The combat power of a 10,10,10 66% IV boss caught when it is fought in boosted weather (level 25)
• min_unboosted_cp - The combat power of a 10,10,10 66% IV boss caught when it is fought in unboosted weather (level 20)
• name - name of the boss
• possible_shiny - true if the boss can be caught as a shiny
• type - Array of types the boss is

Example data

{
    "current": {
        "1": [
            {
                "boosted_weather": [
                    "Clear",
                    "Overcast"
                ],
                "form": "Normal",
                "id": 546,
                "max_boosted_cp": 500,
                "max_unboosted_cp": 400,
                "min_boosted_cp": 453,
                "min_unboosted_cp": 362,
                "name": "Cottonee",
                "possible_shiny": false,
                "tier": 1,
                "type": [
                    "Grass",
                    "Fairy"
                ]
            },
            {
                "boosted_weather": [
                    "Overcast"
                ],
                "form": "Normal",
                "id": 532,
                "max_boosted_cp": 939,
                "max_unboosted_cp": 751,
                "min_boosted_cp": 874,
                "min_unboosted_cp": 699,
                "name": "Timburr",
                "possible_shiny": true,
                "tier": 1,
                "type": [
                    "Fighting"
                ]
            }, ...
        ],
        "2": [...],
        "3": [...],
        "4": [...],
        "5": [...],
        "6": [...],
        "mega": [...]
    },
    "previous": {
        "1": [
            {
                "boosted_weather": [
                    "Clear"
                ],
                "form": "Normal",
                "id": 252,
                "max_boosted_cp": 752,
                "max_unboosted_cp": 601,
                "min_boosted_cp": 695,
                "min_unboosted_cp": 556,
                "name": "Treecko",
                "possible_shiny": true,
                "tier": 1,
                "type": [
                    "Grass"
                ]
            }, ...
        ],
        "2": [...],
        "3": [...],
        "4": [...],
        "5": [...],
        "6": [...],
        "mega": [...]
    }
}

GET /api/v1/research_task_exclusive_pokemon.json

Some Pokemon and their evolutions are only available by completing research tasks. To get these you will have to find the research task by spinning Pokestops and completing it. Once you have completed the task you will be able to claim the reward which may be a Pokemon.

This API returns all Pokemon that are exclusively available from research tasks.

This return an array of dicts with the keys form, id, and name.

Example data

[
    {
        "form": "Normal",
        "id": 327,
        "name": "Spinda"
    }
]

GET /api/v1/mega_pokemon.json

Some Pokemon have the ability to "Mega Evolve" into a stronger form using a temporary evolution. To evolve into the Mega form this requires Mega Energy which is obtained by raiding against Mega Pokemon.

The first time you evolve a Pokemon into its Mega form the energy requirements will be high. Any subsequent Mega Evolutions will have a discounted cost.

Mega forms typically have much stronger stats than the standard forms and boost all Pokemon when used in a raid. Pokemon using moves of the same type as the mega evolved form also are further boosted.

cp_multiplier_override

This returns all possible Mega Pokemon, their stats, typing, and mega energy needed to evolve them.

This return an array of dicts with the following keys:

• first_time_mega_energy_required - The amount of mega energy required to evolve to the Mega form the first time
• form - The form of Mega, some Mega Pokemon have multiple forms
• mega_name - The "common" name of the Mega form, typically "Mega" plus the original Pokemon name
• pokemon_id - The ID of the Pokemon
• pokemon_name - The name of the Pokemon
• stats - A dictionary of stats of the Pokemon with the keys base_attack, base_defense and base_stamina
• type - The type of the Mega Form of the Pokemon
• mega_energy_required - The amount of mega energy required to evolve to the Mega form once it has already been done once
• cp_multiplier_override - If set, this will be used as the level multiplier to calculate the combat points rather than using the standard level based multiplier.

Example data

[
    {
        "first_time_mega_energy_required": 200,
        "form": "Normal",
        "mega_energy_required": 50,
        "mega_name": "Mega Venusaur",
        "pokemon_id": 3,
        "pokemon_name": "Venusaur",
        "stats": {
            "base_attack": 241,
            "base_defense": 246,
            "base_stamina": 190
        },
        "type": [
            "Grass",
            "Poison"
        ]
    },
    {
        "first_time_mega_energy_required": 200,
        "form": "X",
        "mega_energy_required": 50,
        "mega_name": "Mega Charizard X",
        "pokemon_id": 6,
        "pokemon_name": "Charizard",
        "stats": {
            "base_attack": 273,
            "base_defense": 213,
            "base_stamina": 186
        },
        "type": [
            "Fire",
            "Dragon"
        ]
    }, ...
]

GET /api/v1/pokemon_height_weight_scale.json

Pokemon have a number of physical characteristics which define how tall/heavy they are. These are used when deciding if the Pokemon is classified as XS or XL in either weight or height. Weight and height are calculated using a standard average weight and height, with a standard deviation scaling factor added.

In addition to these physical characteristics there are also a number of virtual ones stored. These are used to display the models in the game and are not exposed in the Pokemon Go interface directly.

This API returns the various physical and virtual statistics of the Pokemon.

The return format is an array of dicts with the following keys:

• buddy_scale - The scaling factor used to display the Pokemon when it is your buddy
• form - The form of the Pokemon
• height_standard_deviation - A single standard deviation of height in meters
• model_height - The height of the model used ingame
• model_scale - The scaling factor used to display the Pokemon normally
• pokedex_height - The average height of a Pokemon in meters
• pokedex_weight - The average weight of a Pokemon in kilograms
• pokemon_id - The Pokedex ID of the Pokemon
• pokemon_name - The name of the Pokemon
• weight_standard_deviation - The value of the standard deviation for weight in kilograms

Example data

[
    {
        "buddy_scale": 19.0,
        "form": "Fall_2019",
        "height_standard_deviation": 0.0875,
        "model_height": 0.7,
        "model_scale": 0.89,
        "pokedex_height": 0.7,
        "pokedex_weight": 6.9,
        "pokemon_id": 1,
        "pokemon_name": "Bulbasaur",
        "weight_standard_deviation": 0.8625
    }, {
        "buddy_scale": 19.0,
        "form": "Normal",
        "height_standard_deviation": 0.125,
        "model_height": 1.25,
        "model_scale": 0.89,
        "pokedex_height": 1.0,
        "pokedex_weight": 13.0,
        "pokemon_id": 2,
        "pokemon_name": "Ivysaur",
        "weight_standard_deviation": 1.625
    }, ...
]

GET /api/v1/levelup_rewards.json

Every time you reach the next level in Pokemon Go you are given a small reward package for doing so. In addition to this, you potentially unlock new items that can be received during the game.

This API returns the rewards given for levelling up and notes any items that have been unlocked by reaching the level.

Returns a JSON array of objects. Each object will have the keys items_received, level, and may have unlocked_items.

Example data

[
    {
        "items_received": [
            {
                "amount_received": 20,
                "item": "Poke Ball"
            },
            {
                "amount_received": 10,
                "item": "Potion"
            },
            {
                "amount_received": 10,
                "item": "Revive"
            },
            {
                "amount_received": 1,
                "item": "Incense"
            }
        ],
        "level": 5,
        "unlocked_items": [
            "Potion",
            "Revive"
        ]
    }, ...
]

GET /api/v1/badges.json

While playing Pokemon Go, certain actions are tracked and your progress is logged in the form of badges. When you reach certain milestones you are given a badge to mark your achievement. Standard badges typically have three levels, bronze, silver, and gold. These badges are displayed in your player profile and can be used to judge your progress.

In addition to tracking progress in various statistics, badges are also used to track participation at certain Pokemon Go Special Weekends and events. These badges are called "event badges" and given for participation in the event. This typically requires purchasing a ticket and physically going to the event location.

This API returns the currently available badges in the game and details what is needed to achieve them for non-event badges.

Returns a JSON array of objects. Each object will have the the following keys:

• name - Name of the Badge
• description - Description of the badge
• event_badge - True if the badge is an event badge, false if it is a badge that can be unlocked via normal play
• rank - An integer representing how important the badge is. The lower the number the higher the badge will be displayed in Pokemon Go
• targets (optional) - A list of integers representing the value that you must reach in the badges statistic to gain each level

Example data

[
 {
        "description": "South Korea, July 29, 2018",
        "event_badge": true,
        "name": "Pokemon GO Special Weekend, July 29, 2018",
        "rank": 2
    },
    {
        "description": "Win {0} Gym battles.",
        "event_badge": false,
        "name": "Battle Girl",
        "rank": 4,
        "targets": [
            10,
            100,
            1000
        ]
    }, ...
]

GET /api/v1/gobattle_league_rewards.json

When battling in the Go Battle League you are asked to complete a number of matches. After each match, if successful, you can claim the next reward you are owed. Depending on the rank you are currently in, and whether you are on the free or premium track you will receive a different reward.

The current maximum rewards you can claim are five which is possible if you win all five matches. However it appears that the game master has up to 8 rewards currently possible although the last three are not claimable due to the maximum number of 5 matches.

This API returns currently available rewards for completing a set of battles in a Go Battle League for both free and premium tracks.

This API is a dict where the keys are the Go Battle rank and the values are the different tracks. The track values are a dict with the keys free, premium and rank. Rank is the rank that the tracks relate to, free and premium are an array of awards that you will receive by winning battles.

For each track there are a few different types of objects which relate to the type of reward. Each object has a type field, which relates to the reward type it will give. Each type field will have different keys based on the information.

• type:stardust - If type is set to stardust there will be another key "amount" which has the amount of stardust received
• type:item_from_pool - If type is set to item_from_pool there will be no other keys. A random item will be selected from the pool of possible items.
• type:pokemon_from_pool - If type is set to pokemon_from_pool there will be no other keys. A Pokemon is chosen from the pool of available Pokemon which will either be a random Pokemon or a guaranteed one.
• type:item - If type is set to item there will be two more keys, item_name and amount. You will always be given the fixed number of the named item.

Example data

[
    {
    "1": {
        "free": [
            { "amount": 300, "type": "stardust" },
            { "type": "item_from_pool" },
            { "type": "pokemon_from_pool" },
            { "amount": 3, "item_name": "Rare Candy", "type": "item" },
            { "amount": 600, "type": "stardust" },
            { "amount": 1000, "type": "stardust" },
            { "amount": 1000, "type": "stardust" },
            { "amount": 1000, "type": "stardust" }
        ],
        "premium": [ ... ],
        "rank": 1
    }, ...
]

GET /api/v1/raid_settings.json

In Pokemon Go gyms will sometimes spawn raids which allow multiple players to fight a raid boss. The settings for Pokemon Go raids are encoded into the app and this API provides a simple view of the current raid settings.

This API returns the game master settings for Pokemon Go raids which dictate some important features of raids.

Returns a JSON object with the following keys:

• friend_invite_cooldown_duration - The time in milliseconds you will need to wait between inviting more people to the raid lobby
• friend_invite_cutoff_time - The time in seconds before the raid where you will not be able to invite people
• friends_can_be_invited_in_person - Boolean indicating whether friends can be invited when raiding in person
• friends_can_be_invited_remotely - Boolean indicating whether friends can be invited when raiding with a remote pass (not invited)
• max_friend_invites_per_invite - The maximum number of friends you can invite with one invite selection
• max_friend_invites_per_raid - The maximum number of friends a player can invite per raid
• max_players_per_raid - The maximum number of players that can be in a raid at once
• max_remote_players_per_raid - The maximum number of players who can be in a raid remotely at once
• max_remote_raid_passes - The maximum number of remote raid passes someone can hold before being banned from buying any more (note it is currently possible to hold more if you buy a number when you are under the limit)
• min_player_level_for_remote_raids - The minimum level to access remote raiding in Pokemon Go
• remote_damage_modifier - A decimal representing the damage modifier applied to remote raiders. It has been announced that remote raiders will in the future do less damage than someone in person
• remote_raids_enabled - Boolean indicating whether remote raiding is currently available
• unsupported_remote_raid_levels - Array of raid levels that do not support remote raid invites

Example data

{
    "friend_invite_cooldown_duration": 30000,
    "friend_invite_cutoff_time": 20,
    "friends_can_be_invited_in_person": true,
    "friends_can_be_invited_remotely": true,
    "max_friend_invites_per_invite": 5,
    "max_number_of_friend_invites": 5,
    "max_players_per_raid": 20,
    "max_remote_players_per_raid": 10,
    "max_remote_raid_passes": 3,
    "min_player_level_for_remote_raids": 5,
    "remote_damage_modifier": 1.0,
    "remote_raids_enabled": true
}

GET /api/v1/mega_evolution_settings.json

For Pokemon that can Mega Evolve there are a number of game settings that are applied to them. This API lets you obtain the current Mega Evolution settings associated with Mega Evolving Pokemon and the bonuses this provides.

This API returns the game master settings for Mega Evolutions.

Returns a JSON object with the following keys:

• general_attack_boost - The attack boost given to all Pokemon moves when a Mega Pokemon is in the raid battle
• max_mega_candy - The maximum amount of Mega candy you can hold for a Pokemon
• mega_evolution_duration The number of milliseconds the Mega Evolution will stay Mega Evolved, after which it will devolve back into the original form
• same_type_attack_boost - The attack boost given to all Pokemon moves of the same type as the Mega Pokemon in the raid battle
• walking_buddy_gives_mega_energy - A true/false field which defines whether you will gain candy when walking your buddy you have previously mega evolved.
• mega_evolution_bonus_catch_candy - The amount of candy you will receive in addition to the standard candy when catching a Pokemon of the same type as your current Mega Pokemon

Example data

{
    "general_attack_boost": 1.1,
    "max_mega_candy": 999,
    "mega_evolution_duration": 14400000,
    "same_type_attack_boost": 1.3
}

GET /api/v1/friendship_level_settings.json

When playing Pokemon Go you can add other players as friends. The first time you interact each day you will gain a point in your friendship value. As your friendship points increase you will gain new friendship levels which will bring additional benefits.

By improving your friendship levels you are able to gain additional raid balls, reduce stardust spent when trading, and trade rarer Pokemon between the two friends.

This API returns current friendship levels and the benefits and information associated with being friends with someone at each level.

Returns a JSON array of objects. Each object will have the the following keys:

• allowed_trades - A list of Pokemon categories that you are allowed to trade at your friendship level
• attack_bonus - Attack multiplier that will be applied when raiding with a friend at this level
• friendship_level - Friendship level number, this starts from 0 for someone with 0 friendship points
• friendship_points_required - The minimum friendship points to attain the friendship level
• name - Name of the friendship level
• raid_ball_bonus - The number of raid balls you will gain if raiding with a friend with this level
• trading_discount - The stardust discount when trading a Pokemon with this level friend. 0.96 means the cost will be 96% cheaper than normal.
• xp_reward - The XP reward given when reaching this level of friendship

Example data

[
     {
        "allowed_trades": [
            "Regular Pok\u00e9mon in Pok\u00e9dex"
        ],
        "attack_bonus": 1.0,
        "friendship_level": 0,
        "friendship_points_required": 0,
        "name": "Friend",
        "raid_ball_bonus": 0,
        "trading_discount": 0,
        "xp_reward": 1000
    },
    {
        "allowed_trades": [
            "Regular Pok\u00e9mon in Pok\u00e9dex",
            "Legendary or Shiny Pok\u00e9mon in Pok\u00e9dex",
            "All regular Pok\u00e9mon",
            "All regional Pok\u00e9mon",
            "All Pok\u00e9mon form variants",
            "All Legendary Pok\u00e9mon",
            "All Shiny Pok\u00e9mon"
        ],
        "attack_bonus": 1.03,
        "friendship_level": 1,
        "friendship_points_required": 1,
        "name": "Good Friend",
        "raid_ball_bonus": 0,
        "trading_discount": 0,
        "xp_reward": 3000
    },  ...
]

GET /api/v1/gobattle_ranking_settings.json

In Pokemon Go you are able to fight in the Battle League against other trainers. Here you battle in sets of five matches to receive rewards. At the end of each set if you meet the requirements you will rank up to the next rank.

This holds the details of what you need to do to reach each rank, at which rank you can see your rating, and what you need to be eligible for rewards at the end of the season.

This API returns the game master settings for the Pokemon Go Battle league rankings.

Returns a JSON object with the following keys:

• min_rank_to_display_rating - This is the minimum ranking you must be before your Go Battle league rating is displayed
• rank_requirements - An array of objects with with at least the key rank telling you what you need to achieve to get to that rank level. Other keys include min_rating and additional_battles_required which define the rating you need to achieve to reach the rank and the number of battles you need to win in the previous rank to reach the next.
• requirements_for_rewards - A dict with the keys min_total_battles and rank telling how many battles you have to fight and what rank you must be to be eligible for rewards at the end of the season.

Example data

{
    "min_rank_to_display_rating": 9,
    "rank_requirements": [
        {
            "rank": 1
        },
        {
            "additional_battles_required": 5,
            "rank": 2
        }, ...
        {
            "min_rating": 3000,
            "rank": 10
        }
    ],
    "requirements_for_rewards": {
        "min_total_battles": 5,
        "rank": 1
    }
}

GET /api/v1/baby_pokemon.json

Some Pokemon are only available from eggs and are typically smaller versions of "grown up" Pokemon. These are called baby Pokemon and the only way to get them is typically by hatching them.

This API details all the Pokemon referred to as "Baby Pokemon" which must be obtained by hatching them.

Returns a JSON array of objects with the keys form, id, and name of the baby Pokemon.

Example data

[
    {
        "form": "Normal",
        "id": 172,
        "name": "Pichu"
    },
    {
        "form": "Normal",
        "id": 175,
        "name": "Togepi"
    },
    {
        "form": "Normal",
        "id": 173,
        "name": "Cleffa"
    },
    {
        "form": "Normal",
        "id": 174,
        "name": "Igglybuff"
    }, ...
]

GET /api/v1/pvp_fast_moves.json

Each Pokemon has a fast and charged move. This API allows you to download the full list of fast moves in the current Pokemon Go game master.

Note: This API provides the details of fast moves and their PVP related data which are slightly different from the move data used when raiding.

Returns a JSON array where each element is a dict containing the energy_delta, move_id, name, power, turn_duration and type.

• energy_delta - The change in energy after performing the move
• move_id - The ID of the move in the game master
• name - The name of the move (un-internationalized)
• power - The strength of the move
• turn_duration - The number of turns it takes to make the move (PVP works on a turn based system)
• type - The type of the move

Example data

[
    {
        "energy_delta": 2,
        "move_id": 202,
        "name": "Bite",
        "power": 4,
        "turn_duration": 1,
        "type": "Dark"
    },
    {
        "energy_delta": 7,
        "move_id": 203,
        "name": "Sucker Punch",
        "power": 5,
        "turn_duration": 2,
        "type": "Dark"
    },
    {
        "energy_delta": 3,
        "move_id": 204,
        "name": "Dragon Breath",
        "power": 4,
        "turn_duration": 1,
        "type": "Dragon"
    }, ...
]

GET /api/v1/pvp_charged_moves.json

Each Pokemon has a fast and charged move. This API allows you to download the full list of charged moves in the current Pokemon Go game master.

Note: This API provides the details of fast moves and their PVP related data which are slightly different from the move data used when raiding.

Returns a JSON array where each element is a dict containing the buffs (optional), energy_delta, move_id, name, power, turn_duration, and type.

• buffs - A list of buffs or debuffs which will be applied once the move is performed (optional)
• energy_delta - The change in energy after performing the move
• move_id - The ID of the move in the game master
• name - The name of the move (un-internationalized)
• power - The strength of the move
• turn_duration - The number of turns it takes to make the move (PVP works on a turn based system)
• type - The type of the move

The buffs key is a dict with activation_chance and optionally the following keys target_defense_stat_stage_change, attacker_attack_stat_stage_change, target_attack_stat_stage_change, or attacker_defense_stat_stage_change.

• activation_chance - The chance that the buff/debuff will activate every time the move is used. This goes from 0 to 1 where 0 never happens and 1 happens on every attack
• target_attack_stat_stage_change - The amount of points to modify the target's attack stage
• target_defense_stat_stage_change - The amount of points to modify the targets defense stage
• attacker_attack_stat_stage_change - The amount of points to modify the attackers attack stage
• attacker_defense_stat_stage_change - The amount of points to modify the attackers defense stage

[
  {
        "buffs": {
            "activation_chance": 0.3,
            "target_defense_stat_stage_change": -1
        },
        "energy_delta": -60,
        "move_id": 49,
        "name": "Bug Buzz",
        "power": 90,
        "turn_duration": 1,
        "type": "Bug"
    },
    {
        "energy_delta": -35,
        "move_id": 50,
        "name": "Poison Fang",
        "power": 40,
        "turn_duration": 1,
        "type": "Poison"
    },
    {
        "buffs": {
            "activation_chance": 0.125,
            "attacker_attack_stat_stage_change": 2
        },
        "energy_delta": -35,
        "move_id": 51,
        "name": "Night Slash",
        "power": 50,
        "turn_duration": 1,
        "type": "Dark"
    }, ...
]

GET /api/v1/time_limited_shiny_pokemon.json

In Pokemon Go some Pokemon can only be found as shiny during special events or times of the year. Pokemon Go will announce when these are available and outside of these times it will be impossible to find a shiny variant of this Pokemon.

This API returns all Pokemon that are only shiny during certain events.

This return an array of dicts with the keys form, id, and name.

Example data

[
    {
        "form": "Normal",
        "id": 808,
        "name": "Meltan"
    },
    {
        "form": "Normal",
        "id": 201,
        "name": "Unown"
    },
    {
        "form": "Normal",
        "id": 235,
        "name": "Smeargle"
    },
    {
        "form": "Normal",
        "id": 132,
        "name": "Ditto"
    }
]

GET /api/v1/photobomb_exclusive_pokemon.json

Some Pokemon are only available to be caught after you have taken a photo with your Pokemon and they photobomb it. Once you have a photo that has been photobombed the Pokemon that photobombed you will appear in the world once you close the camera app in Pokemon Go.

Typically you will only be photobombed once a day but typically events will boost this number and add other Pokemon that can photobomb you. For example on community days typically you will be able to be photobombed by the community day Pokemon.

This API returns all Pokemon that are exclusively available to be found after photobombing other Pokemon. These Pokemon will not be found in the wild, through evolution, raiding, or research tasks.

This return an array of dicts with the keys form, id, and name.

Example data

[
    {
        "form": "Normal",
        "id": 235,
        "name": "Smeargle"
    }
]