Record Atlas
3.50M volumes

3,502,257 volumes in the Atlas

Local
Read it · write your research to it · from a spreadsheet, a script, or an AI assistant

Connect to the Atlas

Seven things you can do with the Atlas's data without opening the website, each as a short recipe you can try on this page. And the things that do not work yet, listed honestly.

Read API checking… Sync checking… Ask Claude checking… 57,354 place files 5,943 jurisdiction eras 6,041 given-name forms

You do not need to be a programmer to start. The Atlas keeps everything in plain files with web addresses. A web address you can paste into a browser is already an API. The harder doors (saving your own research) are explained step by step below, and the page will show you exactly what your computer would send, without sending anything.

Pick your door what you want to do

Every file, and the one line that fetches it no key, no login

Everything the Atlas shows is a plain file with a web address. To use one, paste its line into a terminal (curl fetches the file; jq picks out the part you want), or paste just the address into a browser. Each line below was run against the live site and answers. A file's size is shown so you are not surprised.

Providers or collections? They are two different things.

  • providers.json is WHO. An archive or website, such as FamilySearch or a state archive, with what it costs to look.
  • A collection is WHAT. One set of records inside a provider, such as "Croatia, Catholic Church Books 1678–1941", with its years and size. Each row in a place file's collections names its provider by the id in providers.json.
  • So: starting from a place? Read /p/<id>.json. Starting from an archive or a cost? Read providers.json. Want the country-wide FamilySearch collections? Read collections.json.

Where can I look for records?

FileWhat it isFetch it
providers.json
2.5 MB
WHO. One row per archive or website (2,348): what it holds and what it costs to look. Start here for "which archives exist for Croatia, and which are free?".
curl -s https://recordatlas.org/providers.json | jq '.providers[] | select(.countries | index("HR")) | {name, access, url}'
p/senj.json
5 KB
WHAT, for one place. The collections (sets of records) and the individual books (volumes) that cover it, with years, cost and a link. One small file per place; the id is the end of the place page's address.
curl -s https://recordatlas.org/p/senj.json | jq '.collections[] | {provider, title, from, to, access}'
coverage-by-country.json
32 KB
For each country: the years the books cover, and how many volumes and places. Where you could look, not where your family was.
curl -s https://recordatlas.org/coverage-by-country.json | jq '.countries.HR | {from, to, volumes, places}'
collections.json
1.3 MB
WHAT, across a whole country. 3,504 FamilySearch record collections with their years and how many records and images each holds. Country-wide ones (the IGI, a whole country's church books) live only here. FamilySearch's catalogue metadata: no licence is stated for it, so read their terms before reusing it at scale.
curl -s https://recordatlas.org/collections.json | jq '.collections[] | select(.countries | index("HR")) | {title, from, to, records}'
directory.json
456 KB
969 collections people and archives contributed, one row per named collection at a named repository: what it holds, the years, the cost and a link. CC0.

Note. A small, contributed list (60 countries; the US has 504 rows, Britain 103, Italy 43), so it has no rows for Croatia. That says nothing about the Atlas's Croatian coverage, which is large: look in providers.json, coverage-by-country.json and the place files (see the Croatia walk-through below).

curl -s https://recordatlas.org/directory.json | jq '.rows[] | select(.countries | index("IT")) | {repo, name, access}'
provider-contacts.json
27 KB
Where to write to an archive that does not publish its images (only what Wikidata states). Keyed by the provider's Wikidata id.
curl -s https://recordatlas.org/provider-contacts.json | jq '.counts'

Who governed this place, in which year?

FileWhat it isFetch it
regions.json
2.0 MB
Record regions, each a table of eras: the polity that held the ground and the archives its paper went to. The part nobody else publishes.
curl -s https://recordatlas.org/regions.json | jq '.regions[] | select(.id == "kvarner") | .eras[] | {from, to, polity, filedUnder}'
context.json
3.0 MB
The same eras with permanent ids, evidence and a list of gaps. Use this one if you are building something that must not break.
curl -s https://recordatlas.org/context.json | jq '.contract'
flag-index.json
205 KB
Every country's flag page, with the region and the hub it is filed under. Era detail is in flag-eras.json and era-flags.json.
curl -s https://recordatlas.org/flag-index.json | jq '.counts'
history.json
996 KB
Conquests, occupations, migrations, voyages and expeditions, each with dates, a start and an end point, and sources.
curl -s https://recordatlas.org/history.json | jq '.moves | length'

What else might this name be called?

FileWhat it isFetch it
given-names.json
1.5 MB
Given names, every form in every language (Ivan, Johann, Giovanni, Zuane, Joannes). Each form says whether a record showed it, it is only a lead, or a grammar rule makes it.
curl -s https://recordatlas.org/given-names.json | jq '.rows[] | select(.id == "giovanni") | {canon, forms, langs: (.langs | keys)}'
surname-families.json
26 KB
Surname spellings that are one family (Lerena, Llerena, Serena…), and the look-alikes that are NOT.
curl -s https://recordatlas.org/surname-families.json | jq '.rows[] | select(.name == "Lerena") | .forms'
s/leh.json
165 KB
The big surname register, in small files named by the first three letters of a name: which countries have it, and which spellings are linked to it.
curl -s https://recordatlas.org/s/leh.json | jq '.[] | select(.n == "Lehmann") | {n, variants: [.variants[].n]}'
surnames.csv.gz
12.4 MB
The whole surname register in one file, for a spreadsheet or a database. A JSON copy sits beside it (surnames.json.gz).
curl -O https://recordatlas.org/surnames.csv.gz
API: given-name/Ivan One given name answered directly, without downloading the file. Also register words (/v1/term) and old date styles (/v1/date).
curl -s https://api.recordatlas.org/v1/given-name/Ivan | jq '.matches[0]'

What was this place called, and where is it?

FileWhat it isFetch it
place-names.json
130 KB
What a place was called in a given year: Salisbury 1890–1982 is Harare. Dated, each with the page that dates it. Search a register under the name of its year.
curl -s https://recordatlas.org/place-names.json | jq '.places[] | select(.id == "harare") | .names[] | {name, from, to, kind}'
g/zag.json
94 KB
The place-name search: every other name a place is known by (Zagreb is also Agram and Zagabria). Small files named by the first three letters of a name.
curl -s https://recordatlas.org/g/zag.json | jq '.[0] | {name: .[0], country: .[3], also: .[4]}'
index.json
309 KB
The map's list of places (id, name, position, how many books). The busiest places only; the rest are in the pi/ files and index-quiet.json.
curl -s https://recordatlas.org/index.json | jq '.places[0:3]'

What wars, plagues and famines touched this place?

FileWhat it isFetch it
mortality.json
1.3 MB
277 mass-death events (epidemics, famines, wars, massacres, forced removals): the years, a map outline, the countries, the estimated deaths with the range scholars give, and the sources. The outline is a rough area, not a boundary.
curl -s https://recordatlas.org/mortality.json | jq '.events[] | select((.cc // []) | index("HR")) | {n, ty, f, t}'

Which archives, churches, cemeteries and libraries are near here?

FileWhat it isFetch it
world-archives.json
49 KB
Archives at their street address.
curl -s https://recordatlas.org/world-archives.json | jq 'keys'
archives-wikidata.json
1.3 MB
A wider set of archives from Wikidata. Not checked by hand.
curl -s https://recordatlas.org/archives-wikidata.json | jq 'keys'
archives-osm.json
96 KB
Archives from OpenStreetMap. Share-alike licence: see the licence list on the data page.
curl -s https://recordatlas.org/archives-osm.json | jq 'keys'
cemeteries-wikidata.json
3.2 MB
Cemeteries from Wikidata. A second set, from OpenStreetMap, is cemeteries-osm.json (share-alike).
curl -s https://recordatlas.org/cemeteries-wikidata.json | jq 'keys'
churches-wikidata.json
10.0 MB
Churches from Wikidata, useful for finding a parish.
curl -s https://recordatlas.org/churches-wikidata.json | jq 'keys'
libraries-wikidata.json
985 KB
Libraries from Wikidata.
curl -s https://recordatlas.org/libraries-wikidata.json | jq 'keys'

What have researchers already done?

FileWhat it isFetch it
research-sessions.json
460 KB
The books and sources the family archives have searched and what they found: marks only, no names. Your own copy is a different thing: see door 2.
curl -s https://recordatlas.org/research-sessions.json | jq '.archives | keys'

Licences and the full list (including the small per-place and per-name files): Use the data. Files change shape when the site needs them to; read the field you need and ignore the rest.

Everything for one country: Croatia, step by step worked example · every line was run on 19 Nov 2026

You want all the Atlas knows about a country. There is no single "country file", so you ask seven small questions, each answered by one address. Swap HR (the two-letter country code) and croatia-flags for your country and the same lines work. Output is trimmed to a few rows; the shape of each row is what to look at.

  1. Which archives and websites hold records? the live API, JSON
    curl -s "https://api.recordatlas.org/v1/providers?country=HR&limit=100"
    { "total": 49,
      "providers": [
        { "id": "acta-croatica", "name": "Acta Croatica", "kind": "index", "access": "mixed", "countries": ["HR"], "url": "…", "what": "…" },
        { "id": "anno",          "name": "ANNO — Austrian Newspapers Online", "kind": "library", "access": "free", … },
        { "id": "arhinet",       "name": "ARHiNET — Croatian State Archives", "kind": "national-archive", "access": "catalogue", … } ] }
    Format: one object per source (without &limit= you get the first 20 of the total). access says what it costs: free (6), account (2), onsite (8), unsurveyed (20)… The same list is in providers.json, filtered with jq '.providers[] | select(.countries | index("HR"))'.
  2. Which years do the books cover? a file, JSON
    curl -s https://recordatlas.org/coverage-by-country.json | jq '.countries.HR | {from, to, volumes, places, kinds}'
    { "from": 1516, "to": 1994, "volumes": 5361, "places": 1154, "kinds": ["civil","church","census","military"] }
    Add .decades to the jq to get volumes per decade (1850s: 2,709), which draws the histogram on the country page.
  3. Which whole-country FamilySearch collections exist? a file, JSON
    curl -s https://recordatlas.org/collections.json | jq '.collections[] | select(.countries | index("HR")) | {title, from, to, records, images}'
    { "title": "Croatia, Church Books, 1516-1994", "from": 1515, "to": 1994, "records": 7007772, "images": 1421761 }
    { "title": "Croatia, Delnice Deanery Catholic Church Books, 1571-1926", "from": 1570, "to": 1926, "records": 233088, "images": 3485 }
    Only two, because most Croatian books are catalogued as individual volumes per place (step 5), not as one country-wide collection.
  4. Which places? files by map square, JSON
    curl -s https://recordatlas.org/pi/45_15.json | jq '[.places[] | select(.cc == "HR")] | sort_by(-(.v // 0)) | .[0:3] | map({i, n, y, x, v})'
    [ { "i": "zagreb-hr", "n": "Zagreb",  "y": 45.8156,  "x": 15.9881,  "v": 66 },
      { "i": "vukovar",   "n": "Vukovar", "y": 45.34536, "x": 19.00604, "v": 40 },
      { "i": "osijek",    "n": "Osijek",  "y": 45.55355, "x": 18.69058, "v": 36 } ]
    Format: i is the place id, n the name, y/x latitude/longitude, v the volumes. There is no search-by-country call yet, so you read the squares the country sits in: Croatia's places are in pi/45_10, pi/45_15, pi/40_10 and pi/40_15. (Filename = the south-west corner of a 5-degree square.) Or just open the country page.
  5. What exactly can I read for one place? one small file per place
    curl -s https://recordatlas.org/p/senj.json | jq '{region, collections: (.collections | length), volumes: (.volumes | length)}'
    { "region": "vojna-krajina", "collections": 10, "volumes": 7 }
    
    curl -s https://recordatlas.org/p/senj.json | jq '.collections[0] | {provider, title, from, to, access}'
    { "provider": "familysearch", "title": "Births (Rođeni) 1734-1756", "from": 1734, "to": 1756, "access": "account" }
    The id is the one from step 4 (zagreb-hr, senj…). Its region leads to step 6.
  6. Who governed it, and which archive got its paper? a file, JSON
    curl -s https://recordatlas.org/regions.json | jq '.regions[] | select(.id == "vojna-krajina") | .eras[0:2] | map({from, to, regime, polity, filedUnder})'
    [ { "from": 1553, "to": 1746, "regime": "habsburg", "polity": "Habsburg military frontier, under Graz and Vienna", "filedUnder": ["arhinet","familysearch"] },
      { "from": 1746, "to": 1848, "regime": "habsburg", "polity": "Habsburg — the regiment system", "filedUnder": ["arhinet","familysearch","anno"] } ]
    A year equal to a boundary belongs to the newer era. filedUnder are provider ids from step 1. For the country as a whole (18 eras) use context.json: jq '.countries[] | select(.cc == "HR") | .eras'.
  7. Which flags, in which years? a file, JSON, plus a page
    curl -s https://recordatlas.org/flag-index.json | jq '.countries[] | select(.name == "Croatia") | {name, region, hub, flags: (.crowns | length)}'
    { "name": "Croatia", "region": "Balkans", "hub": "Former Yugoslavia", "flags": 18 }
    The era-by-era flags, with their dates, are in context.json (.countries[] | select(.cc == "HR") | .eras[] | {dates, polity, url}), and the page for each is at /flags/croatia-flags/.

Not country-tagged. Wars and plagues (mortality.json) and migrations (history.json) are drawn as shapes and routes with dates, not filed under a country code, so a country filter would be a guess. To find the ones that touched Croatia, read their dates and shapes against the eras above. Names are not per country either: see door 3.

The whole picture four services, one website built on them

How a program talks to the Atlas Your tool on the left reaches four services on the right. Data files and the read API are read-only. Sync stores an encrypted copy of your research. Ask Claude reads a pasted line of a register. Your tool spreadsheet script · app AI assistant your browser Data filesrecordatlas.org/p/senj.json … READ · no key · 57,354 place files Read API + MCPapi.recordatlas.org/v1/… READ · no key · 5 tools Syncsync.recordatlas.org/v1/<id> READ + WRITE · six words · encrypted Ask Claudeai.recordatlas.org/v1/… COMPUTE · metered · writes nothing What you see place pages · the map My research · marks name pages · era tables the same files, drawn
Green = only reads. Gold = reads and writes (your own copy only). The dashed lines are how the website itself uses the same doors.

1 · What sources can I read for a place? read-only, no key

Every place the Atlas knows has one small file at /p/<place-id>.json. It lists the collections (which archive or site holds records for it, what years, what it costs to look) and the volumes (individual books, with their FamilySearch waypoint). The place page you see in the Atlas is drawn from exactly this file.

  1. Find the place id. It is the web address of its page: recordatlas.org/place/senj/ means the id is senj. (There is no search-by-name API yet, see the gaps below.)
  2. Fetch the file. GET https://recordatlas.org/p/senj.json Anyone, no key.
  3. Read collections. Each row is one archive or site: provider, title, from/to years, access (free · account · paid · onsite…), url.
Try it

Press Fetch it: the page will call /p/senj.json and draw what comes back.

The same thing in code
curl -s https://recordatlas.org/p/senj.json | jq '.collections[] | {provider, title, from, to, access}'

// JavaScript (run it on a server or in a script; see the gaps for why a web page on another site cannot)
const place = await (await fetch("https://recordatlas.org/p/senj.json")).json();
for (const c of place.collections) console.log(c.provider, c.title, c.from + "–" + c.to, c.access);

How it looks in the Atlas: the same rows are the "Where the records are" list on the Senj page; access sets the dot's colour (see Help). For a whole country at once: https://api.recordatlas.org/v1/providers?country=HR (the archives and sites, with how each charges).

2 · Keep my own research progress write · six words

There is no account. Your six words are the account.

Six words from a public list of 1,024 words (60 bits: strong against guessing, not against being told, so keep them like a house key). Your browser, or your own tool, turns them into four secrets. The server only ever sees a folder name, two passwords and a sealed box it cannot open.

What the six words become Six words are stretched by PBKDF2 into a master secret, which HKDF splits into a lookup id, a read token, a write token and an encryption key. The key stays with you. The id and tokens go to the server with the sealed copy. six words anchor mimic … you keep these PBKDF2600k× masternever stored HKDF id32 hex · the folder name on the server read tokenproves you may fetch the copy write tokenproves you may replace or delete it AES-256 keyseals your research · stays with you Server holds id · token hashes one sealed box (30 daily copies) cannot open the box sealed boxAES-GCM, bound to your id
The same six words on a phone, a laptop or a script give the same four values, so any of them can fetch and decrypt your copy.

Who holds which secret

ValueGoes to server?What it lets someone do
idyes, in the web addressnothing alone: it only names the folder
read tokenyes, as Authorization: Bearer … on a GETdownload the sealed box (still sealed)
write tokenyes, on PUT and DELETEreplace or erase the box. First save also sends the read token so the server can store its hash.
AES keyneveropen the box. Only your six words make it.

The server stores hashes of the tokens and compares them. A wrong token and an unknown id both answer 404, so it will not even say whether an id exists.

What goes in the box

The same research file the website saves: kind: "record-atlas-research", version 2. One entry per volume you have marked, under the line (family) it belongs to.

{
  "v": 2, "kind": "record-atlas-research", "exported": "2026-11-12",
  "lines": { "kosina-senj": { "name": "Kosina", "where": "Senj", "made": "2026-11-12" } },
  "active": "kosina-senj",
  "marks": {
    "volume:9RK1-T3F": {
      "t": "Births (Rođeni) 1734-1756", "where": "senj", "href": "/place/senj/", "total": 174,
      "walked": [],
      "by": { "kosina-senj": { "done": [[1, 47]], "state": "found", "since": "2026-11-12" } }
    }
  }
}

state is one of planned · written · searched · found · exhausted · blocked. walked is only for a book you read every entry of; it then counts for every family line, so never set it for "I looked for my surname".

Try the keys: nothing is sent anywhere

Throwaway demo

This runs the real key code from the Atlas in your browser. It makes a throwaway phrase (do not use it for real research), shows the values, then builds the exact save request without sending it.

The save, step by step (any language)

  1. Words → keys. PBKDF2-SHA256(phrase, salt "record-atlas-sync-v1", 600000 rounds) → 32 bytes, then HKDF-SHA256 with info = record-atlas-sync/id (16 bytes → hex), /read, /write (32 bytes → base64url) and /enc (the AES key). Words are lower-case, single spaces.
  2. Seal it. AES-256-GCM, a fresh 12-byte IV, the id as associated data. The box is [1][iv][ciphertext+tag].
  3. Save it. PUT https://sync.recordatlas.org/v1/<id> with Authorization: Bearer <write token>, and on the first save also X-Read-Token: <read token>. Body = the box. Answer: {"ok":true,"saved":"…","bytes":1234}.
  4. Get it back. GET /v1/<id> with the read token; /versions lists the last 30 daily copies. DELETE /v1/<id> with the write token erases everything, in both buckets.
A working example (Node 20 or a browser console)
// Node 20+. Download the Atlas's own file once, so the format cannot drift:
//   curl -O https://recordatlas.org/js/research-sync.js
const SY = require("./research-sync.js");                 // same code the website runs (also loads in a browser as window.raResearchSync)
const words = (await (await fetch("https://recordatlas.org/sync-words.json")).json()).words;

const phrase = SY.makePassphrase(words);                  // six words in one string. SAVE THEM: nobody can recover them
const keys   = await SY.deriveKeys(phrase);               // { id, readToken, writeToken, key }
const pack   = JSON.stringify({ v: 2, kind: "record-atlas-research", exported: "2026-11-12",
  lines: { "kosina-senj": { name: "Kosina", where: "Senj", made: "2026-11-12" } }, active: "kosina-senj",
  marks: { "volume:9RK1-T3F": { t: "Births 1734-1756", where: "senj", href: "/place/senj/", total: 174, walked: [],
           by: { "kosina-senj": { done: [[1, 47]], state: "found", since: "2026-11-12" } } } } });
await SY.push(keys, pack);                                // PUT, sealed. Returns { ok, saved, bytes }
const back = await SY.pull(keys);                         // GET, opened. back.text is your JSON; null if nothing is stored
// later, on any machine: SY.deriveKeys(SY.normalisePassphrase(typedWords, words).phrase)

How it looks in the Atlas: open Connection & Backup, choose Restore from my passphrase and type the six words: the marks come back onto My research and onto every volume row on the place pages, as the little state chips below.

planning towritten, no replysearched, nothing found found somethingread everything herecannot get access

3 · Use every spelling of a name read · live API

A register is indexed under the clerk's form, not yours. 711 given names carry 6,041 forms in 57 languages (462 met on a real record), and 127 surname families list their spellings. Each form says whether it was seen on a record, is only a lead (the right form in that language, never yet met) or a rule (made by grammar, like the Latin cases). A lead is something to search, never a finding.

Try it

Press Look it up: the page asks https://api.recordatlas.org/v1/given-name/Ivan.

The same thing in code
curl -s https://api.recordatlas.org/v1/given-name/Ivan
curl -s "https://api.recordatlas.org/v1/term?q=uxoris&record=baptism"       # what a Latin register word means
curl -s -G https://api.recordatlas.org/v1/date --data-urlencode "text=die 30 7bris 1671"  # 30 September 1671 (7bris = September)
# surname spellings are a file, not yet an endpoint:
curl -s https://recordatlas.org/surname-families.json | jq '.rows[] | select(.name=="Defranceschi")'

How it looks in the Atlas: Say your name shows the same families, and every surname page has a "spellings" panel. Writing a new spelling is not an API: it goes through a reviewed catalogue (send it with the evidence).

4 · Places, countries, flags and their eras read · files

The jurisdiction layer has 994 regions with 5,943 eras, and 211 countries with 1,495 eras. Each era says from and to (a year equal to a boundary belongs to the newer era), the regime (a short id such as habsburg, labelled in regimes), the polity, a note, and filedUnder: which provider holds the records for those years. The contract is versioned (now 1.13.0) and described in Use the data. Places without a region, and 52 gaps and 36 overlaps in the table, are listed in context.json as quality: stay silent there.

  1. Place → region. A place file (/p/senj.json) names its region.
  2. Region → eras. /regions.json (2.7 MB; .regions[]) has eras[] for each. Pick the one with from ≤ year < to (to: null means "still").
  3. Era → archive. filedUnder is a list of provider ids; look them up in /providers.json to see what each costs.
  4. Flags. /flag-index.json (211 countries), /era-flags.json (inline art per era), and /flags/<slug>/ pages with the history of each flag.
Try it

Press the button: the page reads the place, its region, and picks the era for that year.

The same thing in code
const place   = await (await fetch("https://recordatlas.org/p/senj.json")).json();
const regions = (await (await fetch("https://recordatlas.org/regions.json")).json()).regions;
const era = regions.find(r => r.id === place.region).eras
              .find(e => e.from <= 1858 && (e.to === null || 1858 < e.to));
console.log(era.regime, era.polity, era.filedUnder);

How it looks in the Atlas: the same rows are the "who governed it" table on a region page, the colour bands when you set a year on the map, and the flag beside each era on a country's flag page.

A researcher's day, using only these doors an example

  1. 1
    Where do I look? /p/senj.json lists ten collections for Senj: FamilySearch, an archive, an index…
  2. 2
    Whose records were they in 1858? Regions → kvarner → the 1815–1918 era is Habsburg; filedUnder names the archives that hold it.
  3. 3
    Which spellings do I search? /v1/given-name/… for the forenames, surname-families.json for the surname.
  4. 4
    Write down what I did. One PUT of the sealed research file keyed by the six words, saying "Births 1734–1756, pages 1–47: found".
  5. 5
    Next day, on the phone. Same six words → same id → GET → decrypt. The marks are back on the map.

What does not work yet found while writing this page

These are real, checked against the live services on 12 November 2026. They are listed in the order a new builder would hit them.

GapWhat happensWhat would fix it
Other websites cannot call most of it from a browserThe data files (recordatlas.org/*.json) send no Access-Control-Allow-Origin header, and Sync and Ask Claude answer browser requests only from recordatlas.org itself (tested: a page on another origin is refused). Only the read API allows any origin. Scripts, spreadsheets and servers are unaffected, because they send no origin.One header in workers/pages/src/index.js for the files; for Sync a deliberate choice (the allow-list is also an abuse guard), perhaps an opt-in list of registered apps.
No place lookup by nameOver the API you cannot ask "which id is Senj?". /index.json lists the 2,606 busiest places with their ids; the rest sit in 170 grid files (/pi/<lat>_<lon>.json, 5-degree squares), so you must know roughly where a place is. The /a/ name files give name, coordinates and country but no id.The planned atlas_find_place, or an id column in the name files.
The API only has five toolsGiven names, register terms, dates, providers by country, and the data contract. Nothing per place, per volume, per surname or per era.atlas_place, atlas_volumes, atlas_eras, atlas_surname (designed in docs/atlas-mcp-plan.md, not built).
You can only write your whole research, not one markSync replaces the whole sealed copy; the newest save wins. Two tools saving at once can overwrite each other, and there is no "add this one mark" call.A merge-on-write endpoint, or a documented read-merge-write recipe with a version check.
Writing needs the encryption done by youNo official library for Python or Node and no test vectors, so a third party must re-implement PBKDF2, HKDF and AES-GCM exactly. The browser file research-sync.js is the only reference.A small published package and a page of known-answer test values.
The six words open both read and writeThere is no read-only phrase to hand a relative or a society. Whoever has the words can also overwrite or erase.A separate "share read-only" code derived from the same words.
No schema for the research fileThe shape above is read off the code. There is no JSON Schema, so a wrong state or range is not refused until the website tries to open it.A published schema, checked on save.
Only your own copy can be writtenThere is no API for adding a provider, a place alias or a spelling to the shared catalogue. Those are proposals reviewed by a person.Propose-first write tools, which are planned, not built.
No keys, quotas or limits are documentedThe read API has optional per-app keys made by hand; limits are dashboard rules. The data page says "no rate limit", which is true of the files, not the Workers.One page of limits per service, and a way to ask for a key.
Sync has hardly been usedThe live counter at https://sync.recordatlas.org/v1/count reports … registrations. It works in tests; it has little real mileage.Ask three researchers to use it for a month and report.
A README still says "not deployed"workers/api/README.md and workers/sync/README.md say not deployed; both answer on the live hosts.Update the READMEs.

How each service works, in detail addresses, formats, how a POST works, examples

Four services sit behind the Atlas: a read API, an MCP server for AI assistants, Sync for keeping your research, and Ask Claude. Each section below says what the service is for, what to send, what you get back, and what goes wrong. Every example is a command you can paste into a terminal. The read API and MCP examples were run against the live services; the sections say plainly which parts were not.

Read API read-only · no key · any website may call it

Five questions the Atlas can answer without you downloading a file: what a given name is called in other languages, what an old register word means, what a date in a register says, which archives hold records for a country, and how fresh the data is.

Addresshttps://api.recordatlas.org/v1/…
MethodGET. (POST is only for /mcp, below.)
KeyNone. You may send an X-Atlas-Key header to name your app; a key that is sent and wrong is refused with 401, so a typo does not pass silently.
BrowsersOpen: any website may call it from a browser (Access-Control-Allow-Origin: *).
FormatJSON, UTF-8. Answers are cached for 5 minutes.
ErrorsA JSON object {"error": "…"} with the right status: 401 unknown key, 404 no such route (the answer lists the routes that exist), 405 wrong method, 500 server error.
HonestyEvery answer names its source file. An empty answer means "not in the catalogue", never "does not exist".

Every example below was run against the live service on 19 Nov 2026.

GET /v1/health

Is it up, and which tools does it have?

Try it
curl -s https://api.recordatlas.org/v1/health
You get
{"ok":true,"v":1,"tools":["atlas_given_name","atlas_term","atlas_date","atlas_providers","atlas_context"],"app":null}
GET /v1/tools

The five tools and exactly what each one takes, as JSON Schema. The same list an MCP client sees.

Try it
curl -s https://api.recordatlas.org/v1/tools | jq '.tools[] | {name, inputs: (.input.properties | keys)}'
You get
{"name":"atlas_given_name","inputs":["name"]}
{"name":"atlas_term","inputs":["record","word"]}
{"name":"atlas_date","inputs":["text"]}
{"name":"atlas_providers","inputs":["access","country","limit","q"]}
{"name":"atlas_context","inputs":[]}
GET /v1/given-name/{name}

Every form of a given name in other languages and in the registers (Ivan, Johann, Giovanni, Zuane and Joannes are one name).

NameWhereNeededWhat it is
namein the pathyesA given name as written, in any language. Case, accents and punctuation are ignored. Exact match only: the Atlas never guesses a "closest" name.
Try it
curl -s https://api.recordatlas.org/v1/given-name/Ivan
You get
{
  "asOf": "2026-11-18",
  "source": "/given-names.json",
  "query": "Ivan",
  "ambiguous": false,
  "note": "status: seen = met on a record; lead = the right form …",
  "matches": [
    {
      "id": "giovanni",
      "canonical": "Giovanni",
      "page": "/name/giovanni/",
      "forms": 186,
      "languages": {
        "italian": [ { "form": "Gio", "status": "attested", "seen": 161 }, … ],
        "english": [ { "form": "Giovanni", "status": "lead", "seen": 453 }, … ],
        … 44 languages
      }
    }
  ]
}
  • If two names answer to what you typed, you get both, with "ambiguous": true. Pick the one you mean.
  • Each form has a status: attested (met on a real record, with a count), lead (the right form in that language, never yet met: search it, never treat it as a finding) or rule (made by grammar, like the Latin cases).
  • You get up to 8 forms per language here. The complete list is in /given-names.json.
If it goes wrongWhat you see
200 with "matches": []The name is not in the catalogue. The answer also has "found": false. That says nobody has added it, not that it is not a name.
GET /v1/term?q={word}&record={kind}

What a word, abbreviation or ending in an old church register means. Latin so far.

NameWhereNeededWhat it is
qquery stringyesThe word as you read it. Other endings, i/j, u/v and signs like 7bris are tolerated.
recordquery stringnobaptism, marriage or burial: narrows the answer to that kind of record.
Try it
curl -s "https://api.recordatlas.org/v1/term?q=uxoris&record=baptism"
You get
{
  "asOf": "…",
  "source": "data/record-terms.json (bundled)",
  "query": "uxoris",
  "count": 1,
  "terms": [
    {
      "id": "uxor",
      "forms": ["uxor", "uxoris", "uxorem", "consors", …],
      "abbreviations": [],
      "means": "wife; spouse",
      "records": "all",
      "role": "person",
      "note": "Handwriting trap: 'uxoris' is often misread as 'ignoris' …",
      "sources": ["https://www.familysearch.org/en/wiki/Latin_Genealogical_Word_List", …]
    }
  ]
}
If it goes wrongWhat you see
200 with "count": 0No card matches. The list is short so far; that is not a finding about the word.
GET /v1/date?text={date as written}

Decode a date as a register wrote it (Latin words, Roman numerals, 7bris for September) into day, month and year, showing the working and any warning.

NameWhereNeededWhat it is
textquery stringyesThe date text, up to 300 characters. Encode spaces: use curl -G with --data-urlencode, as below.
Try it
curl -s -G https://api.recordatlas.org/v1/date --data-urlencode "text=die 30 7bris 1671"
You get
{
  "source": "public/js/record-reader.js",
  "query": "die 30 7bris 1671",
  "ok": true,
  "day": 30, "month": 9, "monthName": "September", "year": 1671,
  "text": "30 September 1671",
  "working": ["30 is day 30", "7bris is September", "1671 is the year 1671"],
  "warnings": []
}
  • warnings is where it tells you a day cannot exist in that month, or that a year is probably Julian-calendar.
GET /v1/providers?country=&access=&q=&limit=

Archives and websites that hold records: what they hold, what it costs to look, when the link was last checked.

NameWhereNeededWhat it is
countryquery stringnoTwo-letter country code, e.g. HR, IT, ZA.
accessquery stringnofree · account · index · mixed · paid · catalogue · onsite · unsurveyed. The answer's accessLegend says what each means.
qquery stringnoA word in the provider's name or id.
limitquery stringno1 to 50, default 20. total says how many matched; shown says how many you got.
Try it
curl -s "https://api.recordatlas.org/v1/providers?country=HR&access=free&limit=1"
You get
{
  "source": "/providers.json",
  "total": 6,
  "shown": 1,
  "accessLegend": { "free": "Images, free, no account", "account": "…", … },
  "providers": [
    {
      "id": "anno",
      "name": "ANNO — Austrian Newspapers Online",
      "url": "https://anno.onb.ac.at/",
      "kind": "library",
      "access": "free",
      "countries": ["AT", "HR", "SI", "IT", "CZ", "SK", "HU"],
      "what": "The Austrian National Library's digitised newspaper run. …",
      "checked": "2026-09-22"
    }
  ]
}
  • what is cut to 400 characters here. The full text is in /providers.json.
GET /v1/context

How fresh the data is, and the rule for reading eras. Call it first if your tool depends on the data being recent.

Try it
curl -s https://api.recordatlas.org/v1/context | jq '{generated, version: .contract.version, counts}'
You get
{
  "generated": "2026-11-18",
  "version": "1.13.0",
  "counts": { "regions": 994, "regionEras": 5943, "countries": 211, "countryEras": 1495, "gaps": 52, "overlaps": 36 }
}
  • The full answer also has the rule (an era covers from <= year < to) and the contract's whole change log, so it is long.

MCP server (for AI assistants) read-only · no key · POST only

MCP (Model Context Protocol) is the standard way an AI assistant calls tools. This address is a remote MCP server. It has the same five tools as the Read API, and an assistant that is connected to it can use them in the middle of a conversation.

  1. In Claude: Settings → Connectors → Add custom connector → paste https://api.recordatlas.org/mcp. No login.
  2. Any other assistant that speaks MCP over streamable HTTP with JSON replies: point it at the same address.
Addresshttps://api.recordatlas.org/mcp
MethodPOST only. A GET answers 405 "This server answers POST only."
BodyOne JSON-RPC 2.0 message, or an array of them. Header Content-Type: application/json.
ReplyJSON with the same id, holding either result or error. A message with no id is a notification: the reply is 202 with an empty body.
StateNone. No session id, no streaming, no login. Every POST stands alone.
BrowsersOpen (CORS *), including the Mcp-Session-Id and MCP-Protocol-Version headers.

Every example below was run against the live service on 19 Nov 2026.

POST /mcp · initialize

The handshake. An assistant sends this first. It answers with what the server is and what it is for.

Try it
curl -s -X POST https://api.recordatlas.org/mcp \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'
You get
{"jsonrpc":"2.0","id":1,"result":{
  "protocolVersion":"2025-06-18",
  "capabilities":{"tools":{}},
  "serverInfo":{"name":"record-atlas","version":"1"},
  "instructions":"Read-only questions about the Record Atlas: given-name spellings, what a register word means, date decoding, archives that hold records. An empty answer is not a finding."}}
  • The protocolVersion you send is echoed back. After it, a client sends the notification notifications/initialized (no id): the server replies 202 with nothing.
POST /mcp · tools/list

Ask what tools there are, with their input schemas.

Try it
curl -s -X POST https://api.recordatlas.org/mcp -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' | jq '.result.tools | map(.name)'
You get
["atlas_given_name","atlas_term","atlas_date","atlas_providers","atlas_context"]
POST /mcp · tools/call

Run one tool. params.name is the tool, params.arguments its inputs (the table below).

Try it
curl -s -X POST https://api.recordatlas.org/mcp -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"atlas_date","arguments":{"text":"die 30 7bris 1671"}}}'
You get
{"jsonrpc":"2.0","id":3,"result":{
  "content":[{"type":"text","text":"{\n \"ok\": true,\n \"day\": 30,\n \"month\": 9,\n \"year\": 1671, …}"}],
  "isError":false}}
  • The answer is result.content[0].text: a STRING that holds the same JSON the Read API returns for that tool. Parse it a second time.
  • isError is true when the tool itself reports a problem (for example, no name given).
POST /mcp · a batch

Send an array and get an array back, in the same order. Notifications inside the array get no entry.

Try it
curl -s -X POST https://api.recordatlas.org/mcp -H 'Content-Type: application/json' \
  -d '[{"jsonrpc":"2.0","id":1,"method":"ping"},{"jsonrpc":"2.0","id":2,"method":"tools/list"}]'
You get
[{"jsonrpc":"2.0","id":1,"result":{}},{"jsonrpc":"2.0","id":2,"result":{"tools":[ … ]}}]

The five tools

ToolArgumentsWhat it does
atlas_given_namename (string, required)Every form of a given name across languages. Same as /v1/given-name/{name}.
atlas_termword (string, required) · record (baptism | marriage | burial)What an old register word means. Same as /v1/term.
atlas_datetext (string, required)Decode a register date. Same as /v1/date.
atlas_providerscountry · access · q · limit (all optional)Archives and websites. Same as /v1/providers.
atlas_contextnoneHow fresh the data is. Same as /v1/context.

What goes wrong, and what you see

CodeMeaningYou see
-32700The body was not JSON.{"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"parse error"}} (HTTP 400)
-32600Valid JSON but not a JSON-RPC 2.0 message (no "jsonrpc":"2.0" or no method)."message":"invalid request"
-32601A method the server does not have. It has: initialize, ping, tools/list, tools/call."message":"method not found"
-32602tools/call with a tool name that does not exist."message":"unknown tool: nope"
405You sent a GET to /mcp.This server answers POST only.

Sync (keep your research) read + write · six words · encrypted

Keeps ONE sealed copy of your research under an id, so a phone and a laptop (or your own script) can share it. The server stores bytes it cannot open: the key that opens them is made from your six words and never leaves your device. There is no account: the id names a folder, and two tokens made from the same six words are the permission.

Addresshttps://sync.recordatlas.org/v1/{id}
id32 hex characters, made from the six words (the step-by-step above shows how).
TokensTwo, each 43 characters of base64url. The write token (PUT, DELETE) and the read token (GET). Sent as Authorization: Bearer <token>. The server keeps only a hash of each.
BodyA sealed box, binary: not JSON. See the box format below. At most 2 MiB.
BrowsersA web page may call it only if it is one of the Atlas's own pages. curl, Node, Python and other scripts send no Origin header and work from anywhere.
KeptThe newest copy for good, plus one older copy per day for 30 days (versions).
Not keptYour words, your key, anything readable. A wrong token and an id that does not exist both answer 404, so it will not even say whether an id exists.

Checked live on 19 Nov 2026: /v1/health, /v1/count, and the 401 and 404 answers below. PUT, GET and DELETE of a real copy are read from the Worker's code, and nothing was saved while writing this page.

GET /v1/health

Is it up?

Try it
curl -s https://sync.recordatlas.org/v1/health
You get
{"ok":true,"v":1}
GET /v1/count

How many people keep a copy. The only number anybody may read; it never names an id. Cached an hour.

Try it
curl -s https://sync.recordatlas.org/v1/count
You get
{"registrations":2,"at":"2026-11-18T03:17:31.262Z"}
PUT /v1/{id}

Save (or replace) your sealed copy. The first save also registers the id.

NameWhereNeededWhat it is
AuthorizationheaderyesBearer <write token>
X-Read-Tokenheaderfirst save onlyThe read token. The server stores its hash so later GETs can be checked.
Content-Typeheadernoapplication/octet-stream
bodybinaryyesThe sealed box (28 bytes to 2 MiB).
Try it
# box.bin is your research JSON, sealed as described below
curl -s -X PUT https://sync.recordatlas.org/v1/<id> \
  -H "Authorization: Bearer <write token>" \
  -H "X-Read-Token: <read token>" \
  -H "Content-Type: application/octet-stream" \
  --data-binary @box.bin
You get
{"ok":true,"saved":"2026-11-19T01:07:19.000Z","day":"2026-11-19","bytes":4128}
  • Last save wins. There is no merge: if two tools save at once, one overwrites the other. Read first, merge on your side, then save.
If it goes wrongWhat you see
400"not an encrypted pack" (first byte is not 1, or too short) · "a first save needs the read token too"
401"a token is needed" (no Authorization header)
403"wrong token" (the write token does not match the one this id was registered with)
413"too large" (over 2 MiB)
GET /v1/{id}

Fetch your newest sealed copy. You decrypt it yourself.

NameWhereNeededWhat it is
AuthorizationheaderyesBearer <read token>
Try it
curl -s -o box.bin -D - https://sync.recordatlas.org/v1/<id> -H "Authorization: Bearer <read token>"
You get
HTTP 200, Content-Type: application/octet-stream
X-Saved-At: 2026-11-19T01:07:19.000Z
(the raw sealed box)
If it goes wrongWhat you see
401{"error":"a token is needed"}
404{"error":"not found"}: nothing saved under that id, OR the token is wrong. They look alike on purpose.
GET /v1/{id}/versions · /v1/{id}/versions/{YYYY-MM-DD}

The first lists the last 30 daily copies. The second fetches one of them (the last copy saved that UTC day), as raw bytes like a normal GET.

NameWhereNeededWhat it is
AuthorizationheaderyesBearer <read token>
Try it
curl -s https://sync.recordatlas.org/v1/<id>/versions -H "Authorization: Bearer <read token>"
You get
{"versions":[{"day":"2026-11-19","bytes":4128,"saved":"2026-11-19T01:07:19.000Z"}, …]}
DELETE /v1/{id}

Erase everything stored for this id, in both buckets (the live one and the nightly copy). Cannot be undone.

NameWhereNeededWhat it is
AuthorizationheaderyesBearer <write token>
Try it
curl -s -X DELETE https://sync.recordatlas.org/v1/<id> -H "Authorization: Bearer <write token>"
You get
{"ok":true,"deleted":3}
If it goes wrongWhat you see
404Not found, or the token is wrong.
GET /v1/{id} with no or a wrong token (checked live)

What the two refusals look like, using an id that does not exist.

Try it
curl -s -w ' [%{http_code}]\n' https://sync.recordatlas.org/v1/00000000000000000000000000000000
curl -s -w ' [%{http_code}]\n' -H "Authorization: Bearer AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" https://sync.recordatlas.org/v1/00000000000000000000000000000000
You get
{"error":"a token is needed"} [401]
{"error":"not found"} [404]

The sealed box: what you PUT

  1. Byte 0: the number 1 (the format version).
  2. Bytes 1 to 12: a fresh random 12-byte IV (nonce), different for every save.
  3. The rest: the research JSON, encrypted with AES-256-GCM. The id (as text) is the associated data. The last 16 bytes are the GCM tag.
  4. So a box is at least 1 + 12 + 16 + 1 = 30 bytes. The server checks only the size and the first byte; it cannot check that the rest is honest.
  5. What goes inside is the research file shown in door 2 (kind "record-atlas-research", version 2). The browser file /js/research-sync.js makes the keys and the box for you.

Ask Claude (reads a pasted line or a photo) metered · bot check · for the Atlas's own pages

Behind the Ask Claude boxes on the Atlas: paste a line of an old register, or a photo of a document, and get a draft reading that leans on the Atlas's reading cards. It calls Claude for you, so it costs money and is rationed.

Read this first. You cannot script the POST routes with curl. Every one needs a Cloudflare Turnstile bot-check token that only a real web page can produce, and it only answers pages on the Atlas's own addresses. What curl CAN do is read the meter (below). If you want AI help inside your own tool, use the MCP server above with your own assistant.

Addresshttps://ai.recordatlas.org/v1/{translate | transcribe | document | casefile}
MethodPOST with a JSON body (about 80 KB at most; a picture up to about 1.6 MB before encoding).
Required headerX-Turnstile: the bot-check token the page got from Cloudflare. Without it: 403 with reason "no-token-sent".
Optional headersX-AI-Id (32 hex) and Authorization: Bearer <43 chars>: the six-word identity. It earns a bigger daily allowance than an anonymous reader.
CostsEach call uses between 1 and 3 of the reader's daily tries; a photo or a whole document costs more than a line of text.
KeepsCounts only. No pasted text, no picture, no answer, no name. Request logging is off.

Checked live on 19 Nov 2026: /v1/health, /v1/allowance, and the refusals marked (checked). The POST bodies and answers are read from the Worker's code and prompts. Nothing was sent that would use a try.

GET /v1/health

Is it on? It can be paused.

Try it
curl -s https://ai.recordatlas.org/v1/health
You get
{"ok":true,"v":1,"enabled":true}
  • When it is paused, every other route answers 503 "Ask Claude is paused for now."
GET /v1/allowance

The meter: how many tries a reader has left today. Open to curl.

NameWhereNeededWhat it is
X-AI-Id + AuthorizationheadersnoSend them to see the identity's own meter. Without them you get the address's meter.
Try it
curl -s https://ai.recordatlas.org/v1/allowance
You get
{"identity":false,"dayLimit":15,"monthLimit":null,"dayUsed":null,"monthUsed":null}
  • dayLimit is how many tries this reader gets a day; dayUsed is how many are gone (null until you send an identity). The daily limit is the service's setting and changes, so read it from here, not from this page.
POST /v1/translate

One line of an old register to a plain-English draft. Uses 1 try.

NameWhereNeededWhat it is
textbodyyesThe line, up to 4,000 characters. One entry at a time.
cardsbodynoUp to 12 reading cards the page matched: {term, forms, meaning, trap}. The page's own matcher makes them; they are tried before the model's own knowledge.
contextbodyno{language, period, place, event}, each short.
Try it
# needs a Turnstile token: this works only from the Atlas's own page
curl -s -X POST https://ai.recordatlas.org/v1/translate \
  -H 'Content-Type: application/json' -H 'X-Turnstile: <token from the widget>' \
  -d '{"text":"die 12 Maii baptizatus est Joannes filius Petri et Mariae","context":{"language":"Latin"}}'
You get
{
  "kind": "translate",
  "result": {
    "draft": "plain-English rendering of the whole line",
    "words": [ { "w": "baptizatus", "gloss": "baptised", "from": "card" | "model", "doubt": false, "why": "" } ],
    "roles": [ { "w": "Joannes", "role": "child" } ],
    "not_said": [ "what the line does NOT tell you, e.g. a baptism date is not a birth date" ],
    "note": "how sure it is overall"
  }
}
  • from says whether a word's meaning came from an Atlas card or from the model. Never treat a "model" reading as settled.
  • If the model's answer cannot be read as JSON you get "result": {"unparsed": true, "draft": "…"} instead.
  • It is told never to invent a surname, a parent, a date or a place that the text does not give.
If it goes wrongWhat you see
400"not json" · "paste a line to read"
403"origin not allowed" (a browser page on another site) · "The bot check did not pass" with a reason (checked: "no-token-sent") · "wrong token" for an identity
413"too large" · "that is too long: paste one entry at a time"
429Allowance used up. The body's limit says which: day, month, site, tokens or sitemonth. Free reads come back at midnight UTC.
503"Claude could not answer just now." with a reason such as anthropic-529. A call that gets no answer costs you nothing.
POST /v1/transcribe

A photo of one line to the line as written, with [?] where it cannot be read. Uses more tries than text (a picture).

NameWhereNeededWhat it is
imagebodyyes{media_type: "image/jpeg" | "image/png" | "image/webp", data: <base64, no prefix>}. The page shrinks the picture first; the limit is about 1.6 MB.
contextbodyno{language}
Try it
curl -s -X POST https://ai.recordatlas.org/v1/transcribe \
  -H 'Content-Type: application/json' -H 'X-Turnstile: <token>' \
  -d '{"image":{"media_type":"image/jpeg","data":"<base64>"},"context":{"language":"Latin"}}'
You get
{ "kind":"transcribe",
  "result": { "lines": [ { "text": "the line as written", "doubtful": ["words it was unsure of"] } ], "note": "one sentence about legibility" } }
  • It copies; it does not translate or explain. An unreadable picture returns no lines and says why in note.
If it goes wrongWhat you see
400"send a jpeg, png or webp picture"
413"that picture is too large: it should be shrunk first"
POST /v1/document

A photo of a whole document (a census sheet, a certificate, a petition) read field by field. Uses more tries than a line; uses a stronger model.

NameWhereNeededWhat it is
imagebodyyesAs for transcribe.
contextbodyno{language, period, place, event, note}, each short.
Try it
curl -s -X POST https://ai.recordatlas.org/v1/document -H 'Content-Type: application/json' -H 'X-Turnstile: <token>' \
  -d '{"image":{"media_type":"image/png","data":"<base64>"},"context":{"period":"1950"}}'
You get
{ "kind":"document",
  "result": { "doc_type", "title_as_printed", "issuer", "date_on_document", "places_named":[…], "what_it_is",
              "persons":[{ "name_as_written", "role", "details":{ "age","born","birthplace","residence","occupation","other" } }],
              "fields":[{ "label","value","doubt" }], "events":[…], "ids":[…], "marks":[…], "not_legible":[…], "legibility" } }
  • It records only what the document states, in the original spelling, and links nothing to any other document.
POST /v1/casefile

Two to six documents that were already read (the results of /document) compared together. Uses more than one try.

NameWhereNeededWhat it is
docsbodyyes2 to 6 of the "result" objects from /v1/document, as an array.
atlasbodynoUp to 3,000 characters of Atlas facts about the places (who ruled them when).
questionbodynoWhat you want to know, up to 500 characters.
Try it
curl -s -X POST https://ai.recordatlas.org/v1/casefile -H 'Content-Type: application/json' -H 'X-Turnstile: <token>' \
  -d '{"docs":[ {…}, {…} ],"question":"Are these the same family?"}'
You get
{ "kind":"casefile",
  "result": { "headline", "groups":[{ "docs":[2,3], "verdict":"likely|possible|unlikely|not enough", "because":[…], "against":[…] }],
              "profile":[{ "fact","evidence","status":"documented|inferred" }], "timeline":[…], "names_and_places":[…],
              "conflicts":[…], "adds":[…], "next_steps":[…], "cautions":[…] } }
  • Every statement is tied to a document number and marked documented, inferred or context. A verdict is a lead for you to check, not a finding.
If it goes wrongWhat you see
400"send two to six documents that were read"
DELETE /v1/id

Forget an identity's counters. Needs the identity's headers (X-AI-Id and the Bearer token).

Try it
curl -s -X DELETE https://ai.recordatlas.org/v1/id -H "X-AI-Id: <32 hex>" -H "Authorization: Bearer <token>"
You get
{"ok":true}

Quick reference every address in one table; details above

AddressMethodNeedsGives you
recordatlas.org/p/<id>.jsonGETnothingone place: collections, volumes, region, parishes
recordatlas.org/regions.jsonGETnothing994 regions and their eras
recordatlas.org/context.jsonGETnothingthe era contract, counts, quality gaps (v1.13.0)
recordatlas.org/providers.jsonGETnothing2,348 archives and sites, with access class
recordatlas.org/given-names.json · surname-families.jsonGETnothingevery form of a name (CC0)
recordatlas.org/flag-index.json · era-flags.json · flag-eras.jsonGETnothingflags by country and era
recordatlas.org/research-sessions.jsonGETnothingwhat the family archives have published
https://api.recordatlas.org/v1/given-name/<name>GETnothingforms of a given name by language
https://api.recordatlas.org/v1/term?q=&record= · /v1/date?text=GETnothingregister words · date reading
https://api.recordatlas.org/v1/providers?country=XX · /v1/contextGETnothingarchives for a country · data build info
https://api.recordatlas.org/mcpPOSTnothingthe same tools for AI assistants (see below)
https://sync.recordatlas.org/v1/<id>PUT · GET · DELETEsix words (tokens)save · fetch · erase your sealed research
https://sync.recordatlas.org/v1/<id>/versions[/<day>]GETread tokenthe last 30 daily copies
https://sync.recordatlas.org/v1/countGETnothinghow many people keep a copy
https://ai.recordatlas.org/v1/translate · transcribe · document · casefilePOSTTurnstile check, optional six-word idClaude reads a pasted line or photo; a few free tries a day
https://ai.recordatlas.org/v1/allowanceGEToptional idtries left today

Using it from an AI assistant

  1. Claude: Settings → Connectors → Add custom connector → paste https://api.recordatlas.org/mcp. No login. You can then ask "what does uxoris mean in a baptism?" or "what is the Latin for Ivan?" and it calls the Atlas.
  2. Any other assistant that speaks MCP: point it at the same address (streamable HTTP, JSON replies).
  3. What it can and cannot do: it reads the five tools above and says which file each answer came from. An empty answer means "not in the catalogue", never "does not exist". It cannot save your research (that needs the six words, which an assistant should never be given).

Built something with this, or hit a wall not listed above?

Tell us · Use the data (files & licences) · Connection & Backup · Help