Skip to content
everloot

Connect

Everloot's data is open. You don't need an account or a key to read it. There are rate limits, but no sign-in wall. Build on it, and credit it. Copying all of it in bulk takes a free key.

This page describes what is live today. Anything that is not built yet says so.

MCP server

Point an AI assistant at Everloot and it can look up lore and the facts players have reported, with the source and licence on every answer.

Hosted endpoint, no sign-in: https://everloot.app/mcp/public

Claude Code

claude mcp add --transport http everloot https://everloot.app/mcp/public

Any client that speaks streamable HTTP

Give it the URL above. Where a client wants a config file, this is the usual shape; check your client's docs for the exact key names.

{
  "mcpServers": {
    "everloot": {
      "type": "http",
      "url": "https://everloot.app/mcp/public"
    }
  }
}

Claude.ai and Claude Desktop

Open Customize, then Connectors, add a connector by URL and paste the endpoint above. It works on every Claude plan, including Free. Once it shows Connected, turn it on in a chat from the plus menu under Connectors and ask about WoW: Forever.

Grok

Grok takes a remote server by URL as a custom connector; for the xAI API, pass the same URL to its remote MCP tools.

ChatGPT and other assistants

Any assistant that takes a streamable HTTP MCP server by URL can use this one; it needs no sign-in and asks for no key, so there is nothing to configure beyond the URL. ChatGPT's connectors and deep research call two tools by name, search and fetch; both are here, answering in the shape OpenAI's contract asks for. Where an assistant has a directory of servers, Everloot is listed there as it is accepted; the listing notes in the repository say where it stands.

Try it with curl

The server keeps no session, so one call is enough. The accept header must list both types.

curl -s https://everloot.app/mcp/public \
  -H "content-type: application/json" \
  -H "accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_by_name","arguments":{"name":"Thrall"}}}'

Tools

  • search_knowledgeSearch lore and reference data. Every hit has its source and licence.
  • get_entityOne record, by the id a search hit gives you.
  • get_by_nameRecords with exactly this name, for telling similar names apart.
  • searchThe same search in the shape ChatGPT connectors and deep research call by name: results with an id, a title and a URL to cite.
  • fetchOne record by a search result's id, whole, with its URL and the source, licence and date as metadata. ChatGPT's second tool.
  • answer_sourcesThe evidence behind a question, each piece with its source, licence and date, so an assistant can answer and cite.
  • profession_pathA leveling path for one profession, from what players reported.
  • recipe_thresholdsThe skill ranges where a recipe turns yellow, green and grey.
  • item_pageOne item: agreed name, drop rate with kill count, map pin.
  • npc_pageOne NPC: agreed name and map pins.
  • object_pageOne game object (a chest, herb, ore vein or fishing pool): the items players looted from it, with loot windows and install counts.
  • quest_pageOne quest: title, level, giver, turn-in and rewards.
  • vendor_pageWhat one vendor sells, with copper prices.
  • world_map_nearWhat is near a spot: entrances, observed NPCs and vendors, with distances in yards.
  • entity_relationsHow an item, NPC, spell or quest connects to others: dropped by, sold by, created by, reagent for, set, same icon. Each relation says if players saw it (3 installs) or the game files hold it (unconfirmed, with the build).
  • item_categoriesItem classes, subclasses, slots and qualities from the game files, with item counts; one item's category path, or the items in a category. Found in game files, unconfirmed, with the build.
  • talent_treeOne class's talent trees from the game files: every node with its talents, ranks, position, prerequisites and row gate. Found in game files, unconfirmed, with the build.
  • talent_planReads a talent share code or calculator link: the talents and ranks it holds, points per tree, the lowest level for it, and every problem in plain words.
  • collection_gapWhat one install is missing from a collection, such as Mounts.
  • completion_progressWhat one install's characters finished in achievements, reputation, titles and quest chains, and what is closest to done.
  • guild_boardA guild's roster, bosses, loot and attendance, from officer uploads.
  • auction_historyDaily median auction price for one item on one realm.
  • market_valueMarket value, minimum buyout, historical value and units listed for one item on one realm, from full scans players started.
  • gold_ledgerPeak gold and money events for one character, from that player's own upload.
  • populationHow many characters play each race, class, faction and level band, from players who turned the census on. Every answer says its window, and a count is hidden when too few players report it.
  • recent_changesRecent Blizzard staff posts, hotfixes and new game builds, newest first, with links to the originals.
  • ecosystem_projectsForever addons and open-source projects, ranked on five boards, with GitHub facts and install counts from 3 installs.
  • everloot_planWhat is built, what is next and what is waiting. Read it before assuming a tool exists.

Tools built on player data show a fact only after enough installs agree on it, and say when it is not recorded yet. Answers from player data end with the age of the data.

Resources

Documents an assistant reads whole, with resources/read, instead of calling a tool with arguments. Their shapes are in /schema/mcp/resources.json.

  • everloot://buildsThe build the game-file facts come from, and every build Blizzard's version service has listed, with when Everloot first saw it. JSON.
  • everloot://methodologyHow uploads become facts: three installs must agree, unrecorded is never zero, game files and play are kept apart, and what is never published. Markdown.
  • everloot://data-policyThe data policy in short: what is published, what is refused, the licence and credit line, and the limits on bulk copying. Markdown.

Entity pages read as resources too, one URI per entity. Each answers with the same JSON as the named tool's structured answer, so a client that prefers resources to tool calls gets the same page.

  • everloot://item/{id}The item_page answer for an item id: agreed name, drop rates with loot-window counts, map pins. The same JSON as item_page's structured answer.
  • everloot://npc/{id}The npc_page answer for an NPC id: agreed name and map pins. The same JSON as npc_page's structured answer.
  • everloot://quest/{id}The quest_page answer for a quest id: title, level, giver, turn-in and rewards. The same JSON as quest_page's structured answer.
  • everloot://vendor/{id}The vendor_page answer for a vendor NPC id: what it sells, with copper prices. The same JSON as vendor_page's structured answer.
  • everloot://object/{id}The object_page answer for an object's entry id: what players looted from it. The same JSON as object_page's structured answer.
  • everloot://talents/{class}The talent_tree answer for a class slug: every node with its talents, ranks, position, prerequisites and gate. The same JSON as talent_tree's structured answer.

Prompts

Ready-made instructions a client offers as commands (prompts/get): you fill the argument, the assistant gets a message that says which tools to call and how to treat what they return. Their arguments are in /schema/mcp/prompts.json.

  • answer_with_sourcesAnswer a question from answer_sources, citing every piece with its source, licence and date. Takes the question.
  • review_talent_planRead a share code with talent_plan and the trees with talent_tree, then describe the build and every problem. Takes the code or a calculator link.
  • what_changedSummarize recent_changes newest first, with links and only the excerpts the tool gives. Takes forever or classic, or nothing for both.

Limits

  • 200 requests per hour for each IP address. Every call counts, including the handshake and the tool list.
  • Over the limit you get 429 and a retry-after header, in seconds.
  • All callers share one hourly cap, which uploads count against too. When it is used up, everyone gets the same 429.
  • Only POST requests count. GET and OPTIONS are not counted.
  • Requests larger than 1 MiB are refused.
  • A free key raises the limit to 2,000 requests per hour.
  • Web pages in a browser can call it only from a short list of AI sites, such as chatgpt.com and claude.ai. Servers, scripts and desktop clients are not affected.

Need more? Write to hello@everloot.app and say what you are building.

Run it yourself

The server is in the repository. This runs the website and the same endpoint on your machine, with a small sample of lore pages.

git clone https://github.com/Everloot/everloot.git
cd everloot
(cd kb && npm install)
cd web && npm install
npm run sample-release    # prints a KB_SNAPSHOT_PATH line
# put that line and EVERLOOT_MCP_PUBLIC=1 in web/.env.local
npm run dev               # MCP at http://localhost:3000/mcp/public

Or run the server over stdio, which clients such as Claude Desktop can launch themselves. Replace the paths with your clone's. The environment line lets the player-data tools read the public corpus below. Add EVERLOOT_API_KEY with your key beside it, or the server stops at the anonymous limit.

{
  "mcpServers": {
    "everloot": {
      "command": "node",
      "args": [
        "/path/to/everloot/kb/node_modules/tsx/dist/cli.mjs",
        "/path/to/everloot/kb/src/cli.ts",
        "serve-mcp",
        "--db",
        "/path/to/everloot/web/.data/release/release.sqlite"
      ],
      "env": {
        "EVERLOOT_PUBLIC_CORPUS_URL": "https://everloot.app/api/corpus/public"
      }
    }
  }
}

The full lore archive is built from the Warcraft Wiki dump. The steps are in kb/README.md.

Tool reference

Every tool, with the arguments it takes. The same list, as JSON Schema, is at /schema/index.json and /schema/mcp/<tool>.json. Tools marked player data state a fact only once three installs agree, say when something is unrecorded, and end their answer with the age of the data and the credit line. The others carry their sources inside the answer. Every tool also returns structuredContent beside the text, of the shape in its schema file; the answer table under each tool lists its top-level fields. Answers built on player data start with connected and dataAsOf, and carry a page only when a corpus was read: an absent page is not a measured zero.

  • search_knowledgeSearch the Everloot knowledge base

    Search WoW lore and Forever reference data. Exact-name matches rank first. Every hit carries its source and licence.

    Arguments of search_knowledge
    ParameterTypeWhat it is
    queryrequiredstring, up to 1000 charactersWhat to look up: names, questions, keywords. Question words are ignored.
    kindone of: item, npc, object, quest, zone, spell, lore_page, creator, realmNarrow to one record kind.
    versionone of: forever, classic, retail, loreNarrow to one game version.
    limitinteger, 1 to 25, default 8

    Answer

    Answer of search_knowledge, as structuredContent
    FieldTypeWhat it is
    hitsrequiredarray of objects

    Schema: /schema/mcp/search_knowledge.json

  • get_entityGet one knowledge record by id

    Fetch the full record behind a search hit id, for page rendering.

    Arguments of get_entity
    ParameterTypeWhat it is
    idrequiredinteger, -9007199254740991 to 9007199254740991Record id from a search_knowledge hit.

    Answer

    Answer of get_entity, as structuredContent
    FieldTypeWhat it is
    hitrequiredobject, or null

    Schema: /schema/mcp/get_entity.json

  • get_by_nameGet records by exact name

    Exact full-name match (case-insensitive) for disambiguation.

    Arguments of get_by_name
    ParameterTypeWhat it is
    namerequiredstring, up to 200 charactersFull record name.
    kindone of: item, npc, object, quest, zone, spell, lore_page, creator, realmNarrow to one record kind.

    Answer

    Answer of get_by_name, as structuredContent
    FieldTypeWhat it is
    hitsrequiredarray of objects

    Schema: /schema/mcp/get_by_name.json

  • fetchFetch one document (ChatGPT connector contract)

    One knowledge record by the id a search result gave, whole: title, the full text in the source's words, the URL to cite, and metadata with the source, licence and date. The text block is the same JSON as a string.

    Arguments of fetch
    ParameterTypeWhat it is
    idrequiredstring, up to 20 charactersAn id from a search result.

    Answer

    Answer of fetch, as structuredContent
    FieldTypeWhat it is
    idrequiredstringThe record id as a string.
    titlerequiredstringThe record's name.
    textrequiredstringThe whole record, in the source's words.
    urlrequiredstringWhere the record is read, as in search.
    metadatarequiredobject

    Schema: /schema/mcp/fetch.json

  • answer_sourcesplayer dataEvidence for a question, each piece with its source

    The evidence behind a question about WoW: Forever, for an answer that cites its sources: facts players observed (public after three installs agree, with the install count), curated facts, and the 2023 Warcraft Wiki (marked: may differ in Forever). Every piece carries a claim, its source URL, licence and date. Returns evidence rather than prose. Further-reading links are search URLs on other sites; nothing is fetched from them. Reads Everloot's current authorized public corpus when connected; when it is not, the observed layer is unrecorded, not empty.

    Arguments of answer_sources
    ParameterTypeWhat it is
    questionrequiredstring, up to 500 charactersThe question, with names spelled as in the game.
    limitinteger, 1 to 25, default 8Most lore and curated pieces.

    Answer

    Answer of answer_sources, as structuredContent
    FieldTypeWhat it is
    evidencerequiredarray of objectsObserved first, then curated, then lore.
    furtherReadingrequiredarray of objectsSearch links on other sites. Nothing was fetched.
    dataAsOfrequiredstring, or nullWhen the observed layer was current; null when it is not connected.

    Schema: /schema/mcp/answer_sources.json

  • profession_pathplayer dataProfession leveling path

    Leveling path for one Forever profession from Everloot uploads. A step exists only after 3 installs agree: on a reported recipe, or on the recipe colours that make it orange (a guaranteed skill-up), starting at the trainer's required rank. Gold exists only after 3 price uploads agree. No copied guide. Reads Everloot's current authorized public corpus when connected. Missing or unavailable data is reported explicitly.

    Arguments of profession_path
    ParameterTypeWhat it is
    professionrequiredstringProfession name, such as Alchemy.
    fromSkillinteger, 1 to 500, default 1Skill the character has now.
    toSkillrequiredinteger, 1 to 500Skill to stop at. Must be above fromSkill.

    Answer

    Answer of profession_path, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/profession_path.json

  • recipe_thresholdsplayer dataRecipe skill ranges

    Where a Forever profession's recipes turn yellow, green and grey, inferred from the colours players' trade-skill windows showed. A recipe appears only after 3 installs agree, as ranges, never guessed exact numbers. Agreed reagents come with an estimated cost per craft when every reagent has an agreed price. Reads Everloot's current public corpus.

    Arguments of recipe_thresholds
    ParameterTypeWhat it is
    professionrequiredstringProfession name, such as Alchemy.
    recipestringOptional part of a recipe name to narrow the list.

    Answer

    Answer of recipe_thresholds, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/recipe_thresholds.json

  • item_pageplayer dataItem page for a drop

    One Forever item: agreed name, public drop rate with kill count, and an agreed map pin. A rate is public after 3 installs kill the source. A name or pin needs 3 installs agreeing. No Wowhead rows. Reads Everloot's current authorized public corpus when connected. Missing or unavailable data is reported explicitly.

    Arguments of item_page
    ParameterTypeWhat it is
    itemIdrequiredinteger, 1 to 9007199254740991Item id from a drop row.

    Answer

    Answer of item_page, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/item_page.json

  • npc_pageplayer dataNPC page

    One Forever NPC: agreed name and map pins. A name or pin needs 3 installs agreeing. The pin does not require a drop. No copied spawn list. Reads Everloot's current authorized public corpus when connected. Missing or unavailable data is reported explicitly.

    Arguments of npc_page
    ParameterTypeWhat it is
    npcIdrequiredinteger, 1 to 9007199254740991NPC id.

    Answer

    Answer of npc_page, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/npc_page.json

  • object_pageplayer dataGame object page

    One game object (a chest, herb, ore vein or fishing pool) by the id in its GUID: the items players looted from it, each with observed loot windows, windows with the item and distinct install reports. A frequency is public after 3 install reports; a public object with nothing in its windows reads as a measured zero. Objects have no names yet. Reads Everloot's current authorized public corpus when connected.

    Arguments of object_page
    ParameterTypeWhat it is
    objectIdrequiredinteger, 1 to 9007199254740991The object's entry id, as in /database/objects/1731.

    Answer

    Answer of object_page, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/object_page.json

  • quest_pageplayer dataQuest page

    One Forever quest: agreed title, level, giver, turn-in, and rewards. Each fact needs 3 installs agreeing. No copied quest text. Reads Everloot's current authorized public corpus when connected. Missing or unavailable data is reported explicitly.

    Arguments of quest_page
    ParameterTypeWhat it is
    questIdrequiredinteger, 1 to 9007199254740991Quest id.

    Answer

    Answer of quest_page, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/quest_page.json

  • vendor_pageplayer dataVendor page

    Goods one Forever vendor sells. An item is listed when 3 installs agree on that item and its copper price. Two agreed prices both stay listed. No copied catalog. Reads Everloot's current authorized public corpus when connected. Missing or unavailable data is reported explicitly.

    Arguments of vendor_page
    ParameterTypeWhat it is
    vendorNpcIdrequiredinteger, 1 to 9007199254740991Vendor NPC id.

    Answer

    Answer of vendor_page, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/vendor_page.json

  • world_map_nearplayer dataWhat is near a place on the map

    Entrances, NPCs and vendors near a spot, nearest first, with straight-line distances in yards. Give a zone (name or map id) with x and y from 0 to 100, or an NPC id to start from where that NPC stands. Entrances come from the game files and are unconfirmed. NPCs and vendors are player-observed and listed only where 3 installs agree on the position. Zones the files hold back as possibly unreleased are not offered. Game objects are not listed: no public record gives them a position. Reads Everloot's current authorized public corpus when connected.

    Arguments of world_map_near
    ParameterTypeWhat it is
    zonestring, up to 80 charactersZone name or map id, such as Elwynn Forest or 1429. Needs x and y.
    xnumber, 0 to 100Across the zone map, 0 (west) to 100 (east).
    ynumber, 0 to 100Down the zone map, 0 (north) to 100 (south).
    npcIdinteger, 1 to 9007199254740991Start from this NPC's agreed position instead of a zone and x, y.
    radiusnumber, above 0, up to 5000, default 500Search radius in yards.
    limitinteger, 1 to 20, default 5Most results per list.

    Answer

    Answer of world_map_near, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/world_map_near.json

  • entity_relationsplayer dataHow an item, NPC, spell or quest connects to others

    Every typed relation of one entity, both directions: dropped by, sold by, reward from, located in (player-observed, listed where 3 installs agree, with the install count and last seen), and created by, reagent for, part of set, same icon (found in game files, unconfirmed, with the build they came from). Ids are the game's own. Reads Everloot's current authorized public corpus and the committed client layer.

    Arguments of entity_relations
    ParameterTypeWhat it is
    kindrequiredone of: item, spell, npc, object, quest, zone, item_set, icon, skillWhat the id names. A zone is a UiMap id, as on /map.
    idrequiredinteger, 1 to 9007199254740991The game's id for it, such as item 19019.
    relone of: dropped_by, sold_by, reward_from, located_in, created_by, reagent_for, part_of_set, same_icon, in_skill_lineOnly this relation.
    directionone of: from, to, bothfrom: what this entity points to (an item's sources). to: what points at it (what an NPC drops). Default both.
    limitinteger, 1 to 100, default 25Most lines per relation.

    Answer

    Answer of entity_relations, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/entity_relations.json

  • item_categoriesItem categories: class, subclass, slot and quality

    Item categories from the game files (found in game files, unconfirmed, with the build): class and subclass with the client's English names and slugs, slot and quality. With no arguments, the whole tree with item counts. With item, that item's category path. With class (a slug such as weapon or armor), and optionally subclass, slot and quality slugs, the items in it. Ids only: item names come from player uploads (item_page).

    Arguments of item_categories
    ParameterTypeWhat it is
    iteminteger, 1 to 9007199254740991An item id: answers its class, subclass, slot and quality.
    classstring, up to 40 charactersClass slug, such as weapon, armor, consumable or trade-goods.
    subclassstring, up to 40 charactersSubclass slug or number within the class, such as one-handed-swords or cloth.
    slotstring, up to 40 charactersSlot slug, such as head, chest, one-hand or trinket.
    qualityone of: poor, common, uncommon, rare, epic, legendary, artifact, heirloompoor, common, uncommon, rare, epic, legendary, artifact or heirloom.
    limitinteger, 1 to 100, default 25Most items listed.

    Answer

    Answer of item_categories, as structuredContent
    FieldTypeWhat it is
    labelrequiredstring
    buildrequiredstring
    itemobject, or nullWith item: its path, or null when the item is not in the build.
    classesarray of objectsWith no arguments: the whole tree, classes with items only.
    itemsarray of objectsWith class: the items in the category, up to limit.
    totalinteger, -9007199254740991 to 9007199254740991With class: how many items match, listed or not.
    errorstringA class or subclass that is not in the build.
    creditrequiredstring

    Schema: /schema/mcp/item_categories.json

  • talent_treeTalent trees for one class

    The WoW: Forever talent trees of one class from the game files (found in game files, unconfirmed, with the build): every node with its talents, ranks, grid position, prerequisites and row gate, plus the levels talent points arrive at. Node ids are the ids a share code names. Narrow to one tree by name. The calculator is at /tools/talents/<class>.

    Arguments of talent_tree
    ParameterTypeWhat it is
    classrequiredone of: warrior, paladin, hunter, rogue, priest, shaman, mage, warlock, druidClass slug.
    treestring, up to 40 charactersOne tree by name, such as Arcane. Without it, every tree.

    Answer

    Answer of talent_tree, as structuredContent
    FieldTypeWhat it is
    labelrequiredstring
    buildrequiredstringThe game build the trees were read from.
    classrequiredone of: warrior, paladin, hunter, rogue, priest, shaman, mage, warlock, druid
    classNamerequiredstring
    specIdrequiredinteger, -9007199254740991 to 9007199254740991The client's spec id, or 0 when unknown.
    pointsrequiredobject
    treesrequiredarray of objects
    nodesrequiredarray of objects
    creditrequiredstring

    Schema: /schema/mcp/talent_tree.json

  • talent_planRead a talent share code

    Decodes an Everloot talent share code (EL1-<class>-<spec>-<build>-<payload>, or a calculator link carrying one after #plan=) against the class's trees: the talents and ranks it holds, points per tree, the lowest level that can hold it, and every problem in plain words: a code made on another build, nodes the tree does not have, ranks cut back, points the rules would not place. Nothing is dropped silently. Game-file data, found in game files, unconfirmed.

    Arguments of talent_plan
    ParameterTypeWhat it is
    coderequiredstring, up to 2000 charactersThe share code, or a link that carries one.

    Answer

    Answer of talent_plan, as structuredContent
    FieldTypeWhat it is
    okrequiredbooleanFalse when the code could not be read at all; message says why.
    messagestring
    classone of: warrior, paladin, hunter, rogue, priest, shaman, mage, warlock, druid
    classNamestring
    codeBuildstringThe game build the code was made on.
    treeBuildstringThe build of the trees it was read against.
    pointsSpentinteger, -9007199254740991 to 9007199254740991
    minLevelinteger, -9007199254740991 to 9007199254740991The lowest level that can hold this many points.
    byTreearray of objects
    talentsarray of objects
    problemsarray of stringOne sentence each. Empty means the code loaded exactly as made.
    linkstringThe calculator with this plan loaded.
    labelrequiredstring
    creditrequiredstring

    Schema: /schema/mcp/talent_plan.json

  • collection_gapplayer dataOwned versus missing in a collection

    Missing items in one collection for one install. A list row is public after 3 installs agree on the collection, the source, and the item. Owned is what that install uploaded. Not a Blizzard profile read and not a copied catalog. Reads Everloot's current authorized public corpus when connected. Missing or unavailable data is reported explicitly.

    Arguments of collection_gap
    ParameterTypeWhat it is
    collectionrequiredstringCollection name, such as Mounts.
    ownerInstallIdrequiredstringInstall id whose owned upload to compare.

    Answer

    Answer of collection_gap, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/collection_gap.json

  • completion_progressplayer dataAchievement, reputation, title and quest progress

    What one install's characters have finished, and what is closest to done: achievements with the largest share of criteria or progress met, reputations nearest the next standing, titles known, and quests finished in a chain. A list entry is public after 3 players (installs uploading from different addresses) report it identically. Progress is shown only when that install uploaded it with the collection sharing choice and a verified grant; without it the answer says so. Not a Blizzard profile read and not a copied catalog. Reads Everloot's current authorized public corpus when connected. Missing or unavailable data is reported explicitly.

    Arguments of completion_progress
    ParameterTypeWhat it is
    ownerInstallIdrequiredstringInstall id whose completion upload to read.
    characterKeystring, up to 8 charactersOne character's 8-digit key from the upload, when the install has several.

    Answer

    Answer of completion_progress, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/completion_progress.json

  • guild_boardplayer dataOfficer guild board

    Roster, bosses, loot, attendance, and average item level from officer uploads. A figure is public after 2 uploads agree. The average names how many roster members were measured. There is no single score because score_v1 weights are not published. Reads Everloot's current authorized public corpus when connected. Missing or unavailable data is reported explicitly.

    Arguments of guild_board
    ParameterTypeWhat it is
    guildNamerequiredstringGuild name.
    realmrequiredstringRealm name.

    Answer

    Answer of guild_board, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/guild_board.json

  • auction_historyplayer dataAuction history for one item

    Price history from auction scans players uploaded on purpose. A day is public after 3 installs scanned that item on that realm. Copper is the median. Reads Everloot's current authorized public corpus when connected. Missing or unavailable data is reported explicitly.

    Arguments of auction_history
    ParameterTypeWhat it is
    realmrequiredstringRealm name.
    itemIdrequiredinteger, 1 to 9007199254740991Item id.

    Answer

    Answer of auction_history, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/auction_history.json

  • market_valueplayer dataForever market value for one item

    Market value, minimum buyout, historical value and units listed for one item on one WoW: Forever realm, from full auction scans players started and uploaded. A day is public after 3 reporters (distinct upload addresses) scanned the item; values are medians, thin days and outlier days are left out of the market value. Market value weights the last 14 public days, historical is the median of 60. Missing or unavailable data is reported explicitly.

    Arguments of market_value
    ParameterTypeWhat it is
    realmrequiredstringRealm name.
    itemIdrequiredinteger, 1 to 9007199254740991Item id.

    Answer

    Answer of market_value, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/market_value.json

  • gold_ledgerplayer dataGold ledger for one character

    Peak gold and the money events that character's own upload recorded. Loot, quests, vendors, and auction sales stay on the money line. Gameplay stays on its own line. A missing line is unrecorded. The difference is not called bought and is not a ban. Installs are not merged. No scan of a player who did not upload. Reads Everloot's current authorized public corpus when connected. Missing or unavailable data is reported explicitly.

    Arguments of gold_ledger
    ParameterTypeWhat it is
    characterrequiredstringCharacter name.
    realmrequiredstringRealm name.

    Answer

    Answer of gold_ledger, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/gold_ledger.json

  • populationplayer dataWho plays what: population by race, class, faction and level

    How many characters play each race, class, race and class, faction and level band on WoW: Forever, from the census of players who turned it on in the Everloot addon. Each character counts once. A count shows only when it covers at least 10 characters reported by at least 3 installs from at least 3 addresses, rounded to the nearest 5, and a count that could be worked out from the others is hidden too. Every answer states its window: active in the last 7 days (default) or since launch. With no arguments, the overview: most played class first. No names, ever. Missing or unavailable data is reported explicitly.

    Arguments of population
    ParameterTypeWhat it is
    racestring, up to 40 charactersA race, such as Gnome, Night Elf or Undead.
    classstring, up to 40 charactersA class, such as Priest.
    factionone of: Alliance, HordeAlliance or Horde.
    windowone of: week, launchweek: active in the last 7 days. launch: seen since launch.

    Answer

    Answer of population, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when no corpus was read; the page is then absent, which is not a measured zero.
    dataAsOfrequiredstring, or nullThe corpus snapshot time, or null when unrecorded.
    reasonstringWhy nothing was read, when connected is false.
    pageobject

    Schema: /schema/mcp/population.json

  • recent_changesRecent official changes for WoW: Forever

    Newest first: Blizzard blue posts (title, author, time, a short excerpt and the link to the original), hotfix posts, and new game builds. Excerpts only: Blizzard's post text is Blizzard's; full posts are available at their source URLs. A build's time is when Everloot first saw it, not Blizzard's release time.

    Arguments of recent_changes
    ParameterTypeWhat it is
    filterone of: all, posts, hotfixes, buildsposts (blue posts), hotfixes, builds, or all.
    gameone of: forever, classicNarrow to one game.
    limitinteger, 1 to 25, default 10

    Answer

    Answer of recent_changes, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when the timeline is not connected: the list is then not a measured zero.
    entriesrequiredarray of objects

    Schema: /schema/mcp/recent_changes.json

  • ecosystem_projectsWoW: Forever addons and open-source projects

    Forever addons and tools from the community registry, with a board ranking: most installed, rising, most active, freshest release or best maintained. Each project shows its GitHub repository, stars, latest release, last commit, whether its .toc declares a Forever interface number, and installs from Everloot uploads (counted from 3 installs; a missing count means not counted, not zero). Projects are ranked, never people. GitHub facts carry the time they were refreshed.

    Arguments of ecosystem_projects
    ParameterTypeWhat it is
    boardone of: all, installed, rising, active, release, maintainedinstalled, rising, active, release, maintained, or all (A to Z).
    forever_ready_onlybooleanOnly projects whose .toc lists a Forever interface number.
    limitinteger, 1 to 25, default 10

    Answer

    Answer of ecosystem_projects, as structuredContent
    FieldTypeWhat it is
    connectedrequiredbooleanFalse when the tracker is not connected: the list is then not a measured zero.
    refreshedAtrequiredstring, or nullWhen the GitHub facts were last refreshed.
    installsAvailablerequiredbooleanFalse when install counts could not be read: a null count then means unknown.
    foreverrequiredobject, or nullWhat Forever-ready compares each .toc with, derived from the build's version and not yet confirmed in the client.
    boardrequiredone of: all, installed, rising, active, release, maintained
    projectsrequiredarray of objects

    Schema: /schema/mcp/ecosystem_projects.json

  • everloot_planEverloot implementation tracker

    The Everloot feature catalogue: what is live, what is next, what is waiting, and which reference sites are page shapes only.

    No parameters.

    Answer

    Answer of everloot_plan, as structuredContent
    FieldTypeWhat it is
    rowsrequiredarray of objectsEvery row, in the tracker's order.
    countsrequiredobject

    Schema: /schema/mcp/everloot_plan.json

Corpus API

Everything players have uploaded that is public, as JSON. One URL, no key.

curl -s "https://everloot.app/api/corpus/public?kinds=loot,vendor"

Parameters

kinds is optional: a comma-separated list of record kinds. Leave it out to get every kind. An unknown kind returns 400.

offset and limit are optional too, for paging. A page holds at most 500 records without a key and 5,000 with one. When there are more records, next is the URL of the next page; otherwise it is null.

Kinds: npc_sighting, loot, quest, vendor, item_seen, guild_snapshot, raid_lockout, attendance, loot_award, gear_snapshot, collection_catalog, collection_owned, auction_scan, recipe_seen, price_seen, recipe_observed, trainer_seen, gold_snapshot, money_event, map_bounds.

Walk every page

Follow next until it is null. The snapshot behind the feed changes about every ten minutes, so one walk gives one consistent view.

// Every loot record, page by page. Stop when next is null.
let url = "https://everloot.app/api/corpus/public?kinds=loot&limit=500";
const records = [];
while (url) {
  const body = await (await fetch(url)).json();
  if (!body.ok) throw new Error(body.error);
  records.push(...body.records);
  url = body.next;
}
console.log(records.length, "loot windows as of", body.dataAsOf);
// Show the credit line wherever these appear: body.attribution.credit
import requests

url = "https://everloot.app/api/corpus/public?kinds=vendor&limit=500"
records = []
while url:
    body = requests.get(url, timeout=30).json()
    if not body["ok"]:
        raise SystemExit(body["error"])
    records.extend(body["records"])
    url = body["next"]
print(len(records), "vendor lists; credit:", body["attribution"]["credit"])

Response

Example values; kinds appears only when you pass it.

{
  "ok": true,
  "uploads": 1,
  "records": [
    {
      "kind": "loot",
      "eventId": "example:1",
      "capturedAt": "2026-10-17T08:00:00.000Z",
      "sourceNpcId": 1234,
      "items": [{ "itemId": 5678, "count": 1 }]
    }
  ],
  "dataAsOf": "2026-10-17T08:50:28.003Z",
  "kinds": ["loot"],
  "offset": 0,
  "limit": 1,
  "total": 1,
  "next": null,
  "attribution": {
    "licence": "CC BY-SA 4.0",
    "licenceUrl": "https://creativecommons.org/licenses/by-sa/4.0/",
    "credit": "Data from Everloot (https://everloot.app), CC BY-SA 4.0.",
    "source": "https://everloot.app/database",
    "terms": "https://everloot.app/terms#licences"
  }
}
  • uploads is how many uploads the records come from.
  • dataAsOf is when the snapshot was current. Check it before you trust a number.
  • Each record has a kind, a capturedAt time and the fields for that kind. Records carry no install id. Named records, such as a guild or a character, appear only when that player chose to share them.
  • These are single reports, not agreed facts. The site and the MCP tools state a fact only after three installs report it. Do the same if you publish numbers.
  • If storage can't be read you get 503 and ok: false. That is not an empty corpus.

The public drop rates are at /api/rollups/drops, with the same paging and limits.

Relations between entities are at /api/edges, also paged and limited: filter with from_kind, from_id, to_kind, to_id, rel and evidence. Relations players saw (3 installs) are ours under the licence above. Relations read from the game files are Blizzard's, found in game files and unconfirmed: they come with their build and a gameData notice instead of our licence. The whole game-file layer of the current build downloads in one file from /api/edges/client-layer.

Item categories (class, subclass, slot and quality, from the game files) are at /api/items, filtered by class, subclass, slot, quality or item and paged the same way; the tree with slugs and counts is at /api/items/categories. They carry the same gameData notice.

Every MCP tool also answers a plain GET at /api/tools/{tool}, with the tool's arguments as query parameters, named and typed as in its schema file (for example /api/tools/item_page?itemId=19019). The answer field is the same structured content an MCP client gets, and text the same words.

curl -s "https://everloot.app/api/tools/get_by_name?name=Thrall" | jq .answer

API reference

Every JSON endpoint. The machine-readable description is /api/openapi.json (OpenAPI 3.1), and each response shape is a JSON Schema file under /schema/api/. Load the OpenAPI file into any client generator or API tool to get typed calls. Every answer says which layer it comes from: facts players observed carry the licence and credit; facts read from the game files carry a gameData notice and their build instead.

  • GET /corpus/publicThe public corpus: every public record players reported, without install ids

    Anonymous observations as records, so anyone can check the counts behind a published fact. `kinds` narrows the body to the record kinds a reader needs. Named records appear only with a grant.

    Access
    per-IP limit, or a free key
    Data
    observed in play
    Paged
    yes: offset, limit, next
    Responses
    200 The page of records. Shape: corpusPublicResponse.400 A parameter is wrong; `error` says which. Shape: apiError.429 Rate limited. `Retry-After` says when to try again. Shape: apiError.503 A dependency is unavailable. The answer is unrecorded, not zero. Shape: apiError.
    Parameters of /api/corpus/public
    ParameterTypeWhat it is
    kindsstringComma-separated record kinds to include. Unknown kinds are a 400.
    offsetinteger, 0 or moreFirst row to return, 0 or more.
    limitinteger, 1 or moreRows per page. Capped at the caller's page size when the data guard is on.
  • GET /rollups/dropsCorroborated drop rates with loot-window counts

    A rate is public once three installs looted its source. Rates come first, then sources looted with nothing in their windows (measured zeros). `kills` counts loot windows players opened, not kills.

    Access
    per-IP limit, or a free key
    Data
    observed in play
    Paged
    yes: offset, limit, next
    Responses
    200 The page of rates and zeros. Shape: dropsResponse.400 A parameter is wrong; `error` says which. Shape: apiError.429 Rate limited. `Retry-After` says when to try again. Shape: apiError.503 A dependency is unavailable. The answer is unrecorded, not zero. Shape: apiError.
    Parameters of /api/rollups/drops
    ParameterTypeWhat it is
    offsetinteger, 0 or moreFirst row to return, 0 or more.
    limitinteger, 1 or moreRows per page. Capped at the caller's page size when the data guard is on.
  • GET /edgesTyped relations between items, NPCs, spells, quests, zones and sets

    Observed edges (dropped by, sold by, reward from, located in) come first and carry install counts; game-file edges (created by, reagent for, part of set, same icon) follow and carry the build. With no filter the whole table pages like the corpus.

    Access
    per-IP limit, or a free key
    Data
    both, labelled per row
    Paged
    yes: offset, limit, next
    Responses
    200 The page of edges. Shape: edgesResponse.400 A parameter is wrong; `error` says which. Shape: apiError.429 Rate limited. `Retry-After` says when to try again. Shape: apiError.503 A dependency is unavailable. The answer is unrecorded, not zero. Shape: apiError.
    Parameters of /api/edges
    ParameterTypeWhat it is
    from_kindone of: item, spell, npc, object, quest, zone, item_set, icon, skillKind of the entity the edge starts from.
    from_idinteger, 1 or moreThe game's id of that entity.
    to_kindone of: item, spell, npc, object, quest, zone, item_set, icon, skillKind of the entity the edge points to.
    to_idinteger, 1 or moreThe game's id of that entity.
    relone of: dropped_by, sold_by, reward_from, located_in, created_by, reagent_for, part_of_set, same_icon, in_skill_lineOnly this relation.
    evidenceone of: observed, clientobserved (players) or client (game files).
    offsetinteger, 0 or moreFirst row to return, 0 or more.
    limitinteger, 1 or moreRows per page. Capped at the caller's page size when the data guard is on.
  • GET /edges/client-layerThe whole game-file relation layer of the current build

    The committed client layer as one object: Blizzard's data, found in game files, unconfirmed. Public in the repository too, so it is neither paged nor limited. Cached for an hour.

    Access
    open
    Data
    in game files, unconfirmed
    Paged
    no
    Responses
    200 The client layer file.

    No parameters.

  • GET /itemsEvery item of the current build with its class, subclass, slot and quality

    From the game files. Filters by one item id, or by class and subclass slugs, slot and quality. Ids only: item names come from player uploads.

    Access
    per-IP limit, or a free key
    Data
    in game files, unconfirmed
    Paged
    yes: offset, limit, next
    Responses
    200 The page of items. Shape: itemsResponse.400 A parameter is wrong; `error` says which. Shape: apiError.429 Rate limited. `Retry-After` says when to try again. Shape: apiError.503 A dependency is unavailable. The answer is unrecorded, not zero. Shape: apiError.
    Parameters of /api/items
    ParameterTypeWhat it is
    iteminteger, 1 or moreOne item id.
    classstringClass slug, such as weapon or armor.
    subclassstringSubclass slug or number within the class. Needs class.
    slotstringSlot slug, such as head or trinket.
    qualityone of: poor, common, uncommon, rare, epic, legendary, artifact, heirloomQuality slug.
    offsetinteger, 0 or moreFirst row to return, 0 or more.
    limitinteger, 1 or moreRows per page. Capped at the caller's page size when the data guard is on.
  • GET /items/categoriesThe item class and subclass tree of the current build, with the slot and quality slugs

    Every class with its subclasses, each with the slug `/api/items` takes and the number of items in the build, plus the slot and quality slugs. From the game files. Public in the repository too, so it is neither paged nor limited. Cached for an hour.

    Access
    open
    Data
    in game files, unconfirmed
    Paged
    no
    Responses
    200 The tree. Shape: itemCategoriesResponse.

    No parameters.

  • GET /market/pricesForever market values from full auction scans players started

    Without `realm`, the realms that have public values. With it, the items with the most units listed on that realm as tuples in `fields` order, copper per unit. A day is public when three reporters scanned the item.

    Access
    per-IP limit
    Data
    observed in play
    Paged
    no
    Responses
    200 Realms when `realm` is absent (marketRealmsResponse), prices when present. Shape: marketPricesResponse.400 A parameter is wrong; `error` says which. Shape: apiError.429 Rate limited. `Retry-After` says when to try again. Shape: apiError.503 A dependency is unavailable. The answer is unrecorded, not zero. Shape: apiError.
    Parameters of /api/market/prices
    ParameterTypeWhat it is
    realmstring, 2 to 40 charactersRealm name. Omit it to list realms.
  • POST /intakeUpload records from an Everloot SavedVariables file

    One envelope of at most 2,000 records and 1 MB. Every record is checked against its kind's schema; the receipt lists what was accepted and what was rejected and why. Named categories need the matching sharing choice and a verified grant. Anonymous, keyed by a random install id; quotas per request and per install.

    Access
    per-IP limit
    Data
    no data
    Paged
    no
    Responses
    200 Stored. Shape: intakeReceipt.400 The body is not JSON, or the grants are malformed. Shape: intakeRefused.413 The body is over 1 MB. Shape: intakeRefused.422 The envelope or every record was refused; the receipt says why. Shape: intakeRefused.429 Rate limited; keep the file and retry after `Retry-After`. Shape: intakeRefused.503 Storage could not confirm the write; keep the file and retry. Shape: intakeRefused.
    Body
    intakeRequest

    No parameters.

  • GET /tools/{tool}One MCP tool's answer over plain HTTP

    Every tool of the MCP server, callable with a GET: the tool's arguments go in the query string (numbers and booleans as plain text), named and typed as in /schema/mcp/{tool}.json. The answer is the tool's structured content, with the same text an MCP client gets. A wrong argument is a 400 that says which; an unknown tool is a 404 that lists the tools. Answers built on player uploads say how old the data is and carry the credit line; game-file answers are labelled unconfirmed with their build.

    Access
    per-IP limit, or a free key
    Data
    both, labelled per row
    Paged
    no
    Responses
    200 The tool's answer. Shape: toolAnswerResponse.400 A parameter is wrong; `error` says which. Shape: apiError.404 No such tool; `error` lists them. Shape: apiError.429 Rate limited. `Retry-After` says when to try again. Shape: apiError.503 A dependency is unavailable. The answer is unrecorded, not zero. Shape: apiError.
    Parameters of /api/tools/{tool}
    ParameterTypeWhat it is
    {tool}requiredone of: search_knowledge, get_entity, get_by_name, search, fetch, answer_sources, profession_path, recipe_thresholds, item_page, npc_page, object_page, quest_page, vendor_page, world_map_near, entity_relations, item_categories, talent_tree, talent_plan, collection_gap, completion_progress, guild_board, auction_history, market_value, gold_ledger, population, recent_changes, ecosystem_projects, everloot_planA tool name from the MCP tool list.
  • GET /healthWhether the public snapshot is fresh

    200 when the corpus snapshot was written recently, 503 otherwise. Metadata only.

    Access
    open
    Data
    no data
    Paged
    no
    Responses
    200 Fresh. Shape: healthResponse.503 Stale, missing or unavailable. Shape: healthResponse.

    No parameters.

OpenAPI

The whole API in one file, for client generators, request tools and assistants that read OpenAPI.

curl -s https://everloot.app/api/openapi.json | jq '.paths | keys'

Schemas and the protocol

The contract behind all of this is one package, @everloot/protocol, version 1.1.0: the 33 record kinds the addon writes, the upload envelope and limits, the 17 response shapes above and the tool table. The site validates uploads with it, the MCP server registers its tools from it, and this page is rendered from it.

  • https://everloot.app/schema/index.json: what is published, with the protocol version.
  • /schema/records/<kind>.json: one JSON Schema (draft 2020-12) per record kind, with the rules the server checks that a schema cannot express written into the description.
  • /schema/upload.json and /schema/limits.json: the upload envelope and its sizes (at most 2,000 records and 1 MB per request).
  • /schema/api/<name>.json and /schema/mcp/<tool>.json: the response shapes and the tool inputs.
  • The source and its changelog: packages/protocol. Semver: a new kind, field or tool is a minor release; a removal, a rename, a new required field or a tighter limit is a major release, and the server accepts the current major and the one before it.

Limits and keys

  • Asking questions needs no key. The MCP server and the market prices answer 200 requests per hour for each IP address, as before.
  • Copying in bulk does. Without a key, the corpus API and the drop list answer 30 requests per hour for each IP address, 500 records a page.
  • A free key raises that to 2,000 requests per hour for your account, across all its keys and every endpoint, 5,000 records a page. Send it as Authorization: Bearer <key>.
  • Over a limit you get 429, a retry-after header and a message that points here.
  • A key belongs to your Battle.net account, and we count requests per key. That is how we know who copies the data in bulk, so we can ask what they are building. You can hold 5 keys, make up to 10 a day, and revoke or delete any of them here. We revoke a key that is used to republish the data without credit.
  • We keep a key's daily request counts for 90 days. A revoked key and its counts are deleted 30 days after it was revoked, or at once when you delete it. To delete your account and everything tied to it, write to hello@everloot.app.
  • The site's pages have none of these limits. Search engines and AI assistants are welcome to read and quote them.

Your keys

Checking your account…

Data files

The published data as files: one newline-delimited JSON file per dataset (the public corpus, drop rates, relations, items) and an index.json that lists each file with its row count, size, SHA-256, licence and the API response whose rows it holds, so a file and the API never disagree on a shape. Each export is its own folder, never changed after it is written; latest.json points at the newest. The index shape is /schema/api/bulkIndex.json.

curl -s https://data.everloot.app/latest.json | jq -r .index   # the newest export's index.json

Licence and credit

  • Data: CC BY-SA 4.0. You may reuse it with credit, and what you build from it stays under the same licence.
  • Lore: from the Warcraft Wiki dump of 2023-11-13, CC BY-SA 4.0. Every MCP hit carries its source URL and licence. Keep them with the text.
  • Not ours: World of Warcraft and Blizzard's game data belong to Blizzard. Downloads, the API and the MCP server carry ids and facts. Blizzard's icons, tooltip text and art are never in them.
  • Table names: where a page or file shows column names from game tables, they come from WoWDBDefs by the wowdev contributors, CC BY-SA 4.0.
  • Code: AGPL-3.0-only.
  • Name and logo: not licensed. Say your project uses Everloot data, but give it its own name. See TRADEMARKS.md.

Credit line

Data from Everloot (https://everloot.app), CC BY-SA 4.0.

Link it wherever the data appears. If you show lore text, credit the Warcraft Wiki as well, as each hit says.

Every answer carries the credit line, so it is hard to lose by accident. The JSON APIs have an attribution field with the licence, the credit line and the page the data comes from, and send the same in the X-Everloot-Licence, X-Everloot-Credit and Link headers. MCP answers built on player data end with the licence and credit. Republishing the data without it breaks the licence.

Where the data comes from and what we refuse to use: DATA_POLICY.md. Every third-party source and licence: THIRD_PARTY.md.

Questions or a bug? Contact us or open an issue.