Atlas Academy (Fate/Grand Order) API

Free Fate/Grand Order API with no key: servants, craft essences, skills, noble phantasms and quests from the live NA and JP game data, at three levels of detail. Live example.

No API key requiredCORS enabledHTTPSFree tier

Endpoint tested and returned HTTP 200 on 2026-08-21

What is the Atlas Academy (Fate/Grand Order) API?

Atlas Academy's API is a free, key-free interface to Fate/Grand Order's own game data. It serves servants, craft essences, skills, noble phantasms, items and quests from both the NA and JP regions, at three verbosity levels — basic, nice and raw.

The three-tier design is the thing to understand first. `/basic/` returns a summary suitable for a list view, `/nice/` returns a fully denormalised record with every skill and noble phantasm expanded, and `/raw/` returns the game's own unprocessed tables. The size difference between basic and nice is more than an order of magnitude, so building a servant browser means basic for the grid and nice only on the detail view — fetching nice for a list will take seconds and megabytes.

Then there is the identity problem. A servant has both an `id` (100100) and a `collectionNo` (2), and they are not interchangeable: `collectionNo` is the number players see in-game and quote to each other, while `id` is the internal key the API paths use. Build any user-facing search on `collectionNo` and map it internally. The `traits` array is similarly worth understanding — it is a list of `{id, name}` pairs encoding everything from gender and class to `weakToEnumaElish` and `knightsOfTheRound`, and it is what damage calculators actually run on.

Quick facts

Base URL: https://api.atlasacademy.io
Authentication: No key or account. Atlas Academy publishes an OpenAPI schema at /docs with an interactive explorer.
Rate limit: No rate-limit headers are returned. Responses are heavily cached upstream; the `nice` endpoints are expensive, so cache them locally too.
Pricing: Free, community-run.
CORS: Enabled — callable directly from browser JavaScript
Official docs: Read the docs

How to use the Atlas Academy (Fate/Grand Order) API

Every request below was executed against the live API on 2026-08-21, and the response shown is the real body it returned — not an illustration.

1. Fetch a Fate/Grand Order servant's basic record

GET https://api.atlasacademy.io/basic/NA/servant/100100

curl

curl 'https://api.atlasacademy.io/basic/NA/servant/100100'

JavaScript (fetch)

const res = await fetch("https://api.atlasacademy.io/basic/NA/servant/100100");
if (!res.ok) throw new Error(`Request failed: ${res.status}`);
const data = await res.json();
console.log(data);

Python (requests)

import requests

res = requests.get("https://api.atlasacademy.io/basic/NA/servant/100100", timeout=20)
res.raise_for_status()
print(res.json())

Response — HTTP 200 (truncated)

{
  "id": 100100,
  "collectionNo": 2,
  "name": "Altria Pendragon",
  "originalName": "Altria Pendragon",
  "type": "normal",
  "flag": "normal",
  "flags": [],
  "classId": 1,
  "className": "saber",
  "attribute": "earth",
  "traits": [
    {
      "id": 2,
      "name": "genderFemale"
    },
    {
      "id": 100,
      "name": "classSaber"
    },
    {
      "id": 201,
      "name": "attributeEarth"
    },
    {
      "id": 300,
      "name": "alignmentLawful"
    },
    {
      "id": 303,
      "name": "alignmentGood"
    },
    {
      "id": 405,
      "name": "fiveStarServant"
    },
    {
      "id": 1000,
      "name": "servant"
    },
    {
      "id": 2001,
      "name": "humanoid"
    },
    {
      "id": 2002,
      "name": "dragon"
    },
    {
      "id": 2007,
      "name": "saberface"
    },
    {
      "id": 2008,
      "name": "weakToEnumaElish"
    },
    {
      "id": 2009,
      "name": "riding"
    },
    {
      "id": 2010,
      "name": "arthur"
    },
    {
      "id": 2011,
      "name": "skyOrEarthServant"
    },
    {
      "id": 2037,
      "name": "skyOrEarthExceptPseudoAndDemiServant"
    },
    {
      "id": 2075,
      "name": "saberClassServant"
    },
    {
      "id": 2113,
      "name": "king"
    },
    {
      "id": 2631,
      "name": "hominidaeServant"
    },
    {
      "id": 2780,
      "name": "hasCostume"
    },
    {
      "id": 2795,
      "name": "knightsOfTheRound"
    },
    {
      "id": 2858,
      "name": "standardClassServant"
    },
    {
      "id": 2883,
      "name": "FSNServant"
    },
    {
      "id": 5000,

Parameters

Parameter	Type	Required	Description
`verbosity`	path segment	Required	`basic`, `nice` or `raw`. Controls how much is expanded and can change response size by orders of magnitude. `basic`
`region`	path segment	Required	`NA` or `JP`. JP runs roughly two years ahead, so content differs between them. `NA`
`entity`	path segment	Required	`servant`, `equip`, `skill`, `NP`, `item`, `quest`, `war` and others. `servant`
`lang`	query	Optional	On JP endpoints, request English names where translations exist. `en`
`name`	query	Optional	Search parameter on the `/search` variants of each entity path. `Altria`

Response fields

idinteger: Internal servant id used in API paths — 100100 in our capture. This is not the number players quote.
collectionNointeger: The in-game collection number (2 for Altria Pendragon). Use this for anything user-facing.
name / originalNamestring: Localised name and the original as stored. They differ on translated JP content.
classNamestring: Servant class in lowercase — `saber`, `archer`, `lancer` and so on, with `classId` giving the numeric form.
attributestring: Alignment attribute (`earth`, `sky`, `human`, `star`, `beast`) used in the damage triangle.
traitsarray of objects: `{id, name}` pairs covering gender, class, alignment, rarity and special flags such as `weakToEnumaElish`. The array is the real data model — damage calculations key off it.
type / flag / flagsstring / array: Entity classification. `normal` for a standard playable servant; enemies and events use other values, so filter on this when listing.

What you can build with the Atlas Academy (Fate/Grand Order) API

Build a servant browser or team planner
Implement an FGO damage calculator driven by class and trait data
Compare NA and JP rosters to see what is coming
Look up skill and noble phantasm effects for a wiki
Generate summoning-banner reference pages from live game data

Common errors and how to fix them

404

Unknown id, or the entity does not exist in that region yet.

Fix: JP is ahead of NA — a servant present on JP will 404 on NA until release. Check both regions before assuming a bad id.

A very slow or very large response

You requested `/nice/` for a list rather than a single record.

Fix: Use `/basic/` for lists and `/nice/` only when rendering one entity's detail view.

Confusion between id and collectionNo

Searching by the number shown in-game against the `id` path returns the wrong servant or a 404.

Fix: Map `collectionNo` to `id` once at startup by fetching the basic servant list, then use ids internally.

Atlas Academy (Fate/Grand Order) API — frequently asked questions

Is there a free Fate/Grand Order API?

Yes. Atlas Academy publishes an open API over FGO's game data with no key or account, covering servants, craft essences, skills, noble phantasms, items and quests for both the NA and JP regions.

What is the difference between basic, nice and raw?

They are verbosity levels. `basic` is a summary for list views, `nice` is fully denormalised with skills and noble phantasms expanded, and `raw` is the game's own unprocessed tables. Use basic for lists — nice responses are an order of magnitude larger.

What is collectionNo versus id?

`collectionNo` is the number players see in-game and use in conversation; `id` is the internal key used in API paths. They are different numbers for the same servant, so search on `collectionNo` and translate to `id` before making requests.

Does the API cover both NA and JP?

Yes, as separate path segments. JP typically runs about two years ahead of NA, so a servant may exist on JP and 404 on NA. Deciding which region your app targets is the first thing to settle.

Tools that pair with this API

JSON Formatter

Format, beautify and minify JSON online with 2-space, 4-space or tab indentation. Sort keys alphabetically and catch syntax errors instantly — free and private.

JSON Flattener

Flatten nested JSON into single-level dot-notation keys online. Choose the separator, bracket or dotted array indexes, and copy or download the result.

JSON to CSV Converter

Convert a JSON array of objects to CSV online. Automatic column headers from the union of all keys, delimiter choice and proper quoting — all in-browser.

Atlas Academy (Fate/Grand Order) is an independent third-party service and is not affiliated with ByteTools or ByteVancer. Details on this page were verified on 2026-08-21; always check the official documentation before relying on this API in production, as terms and limits can change.