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.
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
- 1 Sources for a placeArchives, registers and year-ranges for one village. Read-only.
- 2 Save my researchWrite “I searched this book” from your own tool. Needs the six words.
- 3 Spellings of a nameIvan is Johann is Giovanni. Ask once, search them all.
- 4 Who governed itPlaces, countries, flags and their eras, with the years and polity.
- 5 A whole countryA walk-through for Croatia: archives, years, places, eras and flag.
- 6 Every fileNames, places, wars, archives, cemeteries. One curl line each.
- 7 How the APIs workAddresses, formats, POST, the MCP server, and what goes wrong.
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.jsonis 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
collectionsnames its provider by the id inproviders.json. - So: starting from a place? Read
/p/<id>.json. Starting from an archive or a cost? Readproviders.json. Want the country-wide FamilySearch collections? Readcollections.json.
Where can I look for records?
| File | What it is | Fetch it |
|---|---|---|
providers.json2.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.json5 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.json32 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.json1.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.json456 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.json27 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?
| File | What it is | Fetch it |
|---|---|---|
regions.json2.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.json3.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.json205 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.json996 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?
| File | What it is | Fetch it |
|---|---|---|
given-names.json1.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.json26 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.json165 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.gz12.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?
| File | What it is | Fetch it |
|---|---|---|
place-names.json130 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.json94 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.json309 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?
| File | What it is | Fetch it |
|---|---|---|
mortality.json1.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?
| File | What it is | Fetch it |
|---|---|---|
world-archives.json49 KB | Archives at their street address. | curl -s https://recordatlas.org/world-archives.json | jq 'keys' |
archives-wikidata.json1.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.json96 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.json3.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.json10.0 MB | Churches from Wikidata, useful for finding a parish. | curl -s https://recordatlas.org/churches-wikidata.json | jq 'keys' |
libraries-wikidata.json985 KB | Libraries from Wikidata. | curl -s https://recordatlas.org/libraries-wikidata.json | jq 'keys' |
What have researchers already done?
| File | What it is | Fetch it |
|---|---|---|
research-sessions.json460 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.
- 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 thetotal).accesssays what it costs:free(6),account(2),onsite(8),unsurveyed(20)… The same list is inproviders.json, filtered withjq '.providers[] | select(.countries | index("HR"))'. - 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.decadesto thejqto get volumes per decade (1850s: 2,709), which draws the histogram on the country page. - 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. - 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:iis the place id,nthe name,y/xlatitude/longitude,vthe volumes. There is no search-by-country call yet, so you read the squares the country sits in: Croatia's places are inpi/45_10,pi/45_15,pi/40_10andpi/40_15. (Filename = the south-west corner of a 5-degree square.) Or just open the country page. - 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…). Itsregionleads to step 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.filedUnderare provider ids from step 1. For the country as a whole (18 eras) usecontext.json:jq '.countries[] | select(.cc == "HR") | .eras'. - 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 incontext.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
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.
- Find the place id. It is the web address of its page:
recordatlas.org/place/senj/means the id issenj. (There is no search-by-name API yet, see the gaps below.) - Fetch the file.
GET https://recordatlas.org/p/senj.jsonAnyone, no key. - Read
collections. Each row is one archive or site:provider,title,from/toyears,access(free · account · paid · onsite…),url.
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.
Who holds which secret
| Value | Goes to server? | What it lets someone do |
|---|---|---|
id | yes, in the web address | nothing alone: it only names the folder |
read token | yes, as Authorization: Bearer … on a GET | download the sealed box (still sealed) |
write token | yes, on PUT and DELETE | replace or erase the box. First save also sends the read token so the server can store its hash. |
AES key | never | open 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
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)
- Words → keys.
PBKDF2-SHA256(phrase, salt "record-atlas-sync-v1", 600000 rounds) → 32 bytes, thenHKDF-SHA256withinfo=record-atlas-sync/id(16 bytes → hex),/read,/write(32 bytes → base64url) and/enc(the AES key). Words are lower-case, single spaces. - Seal it.
AES-256-GCM, a fresh 12-byte IV, the id as associated data. The box is[1][iv][ciphertext+tag]. - Save it.
PUT https://sync.recordatlas.org/v1/<id>withAuthorization: Bearer <write token>, and on the first save alsoX-Read-Token: <read token>. Body = the box. Answer:{"ok":true,"saved":"…","bytes":1234}. - Get it back.
GET /v1/<id>with the read token;/versionslists 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.
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.
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.
- Place → region. A place file (
/p/senj.json) names itsregion. - Region → eras.
/regions.json(2.7 MB;.regions[]) haseras[]for each. Pick the one withfrom ≤ year < to(to: nullmeans "still"). - Era → archive.
filedUnderis a list of provider ids; look them up in/providers.jsonto see what each costs. - Flags.
/flag-index.json(211 countries),/era-flags.json(inline art per era), and/flags/<slug>/pages with the history of each flag.
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
- 1Where do I look?
/p/senj.jsonlists ten collections for Senj: FamilySearch, an archive, an index… - 2Whose records were they in 1858? Regions →
kvarner→ the 1815–1918 era is Habsburg;filedUndernames the archives that hold it. - 3Which spellings do I search?
/v1/given-name/…for the forenames,surname-families.jsonfor the surname. - 4Write down what I did. One
PUTof the sealed research file keyed by the six words, saying "Births 1734–1756, pages 1–47: found". - 5Next 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.
| Gap | What happens | What would fix it |
|---|---|---|
| Other websites cannot call most of it from a browser | The 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 name | Over 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 tools | Given 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 mark | Sync 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 you | No 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 write | There 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 file | The 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 written | There 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 documented | The 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 used | The 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
- MCP server (for AI assistants)
- Sync (keep your research)
- Ask Claude (reads a pasted line or a photo)
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.
Address https://api.recordatlas.org/v1/… Method GET. (POST is only for /mcp, below.) Key None. 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. Browsers Open: any website may call it from a browser (Access-Control-Allow-Origin: *). Format JSON, UTF-8. Answers are cached for 5 minutes. Errors A 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. Honesty Every 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).
Name Where Needed What it is namein the path yes A 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 wrong What 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.
Name Where Needed What it is qquery string yes The word as you read it. Other endings, i/j, u/v and signs like 7bris are tolerated. recordquery string no baptism, 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 wrong What 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.
Name Where Needed What it is textquery string yes The 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.
Name Where Needed What it is countryquery string no Two-letter country code, e.g. HR, IT, ZA. accessquery string no free · account · index · mixed · paid · catalogue · onsite · unsurveyed. The answer's accessLegend says what each means. qquery string no A word in the provider's name or id. limitquery string no 1 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.
- In Claude: Settings → Connectors → Add custom connector → paste https://api.recordatlas.org/mcp. No login.
- Any other assistant that speaks MCP over streamable HTTP with JSON replies: point it at the same address.
Address https://api.recordatlas.org/mcp Method POST only. A GET answers 405 "This server answers POST only." Body One JSON-RPC 2.0 message, or an array of them. Header Content-Type: application/json. Reply JSON 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. State None. No session id, no streaming, no login. Every POST stands alone. Browsers Open (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
Tool Arguments What 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_contextnone How fresh the data is. Same as /v1/context.
What goes wrong, and what you see
Code Meaning You 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.
Address https://sync.recordatlas.org/v1/{id} id 32 hex characters, made from the six words (the step-by-step above shows how). Tokens Two, 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. Body A sealed box, binary: not JSON. See the box format below. At most 2 MiB. Browsers A 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. Kept The newest copy for good, plus one older copy per day for 30 days (versions). Not kept Your 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.
Name Where Needed What it is Authorizationheader yes Bearer <write token> X-Read-Tokenheader first save only The read token. The server stores its hash so later GETs can be checked. Content-Typeheader no application/octet-stream bodybinary yes The 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 wrong What 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.
Name Where Needed What it is Authorizationheader yes Bearer <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 wrong What 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.
Name Where Needed What it is Authorizationheader yes Bearer <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.
Name Where Needed What it is Authorizationheader yes Bearer <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 wrong What 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
- Byte 0: the number 1 (the format version).
- Bytes 1 to 12: a fresh random 12-byte IV (nonce), different for every save.
- 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.
- 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.
- 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.
Address https://ai.recordatlas.org/v1/{translate | transcribe | document | casefile} Method POST with a JSON body (about 80 KB at most; a picture up to about 1.6 MB before encoding). Required header X-Turnstile: the bot-check token the page got from Cloudflare. Without it: 403 with reason "no-token-sent". Optional headers X-AI-Id (32 hex) and Authorization: Bearer <43 chars>: the six-word identity. It earns a bigger daily allowance than an anonymous reader. Costs Each 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. Keeps Counts 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.
Name Where Needed What it is X-AI-Id + Authorizationheaders no Send 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.
Name Where Needed What it is textbody yes The line, up to 4,000 characters. One entry at a time. cardsbody no Up 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. contextbody no {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 wrong What 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).
Name Where Needed What it is imagebody yes {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. contextbody no {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 wrong What 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.
Name Where Needed What it is imagebody yes As for transcribe. contextbody no {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.
Name Where Needed What it is docsbody yes 2 to 6 of the "result" objects from /v1/document, as an array. atlasbody no Up to 3,000 characters of Atlas facts about the places (who ruled them when). questionbody no What 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 wrong What 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
Address Method Needs Gives you recordatlas.org/p/<id>.jsonGET nothing one place: collections, volumes, region, parishes recordatlas.org/regions.jsonGET nothing 994 regions and their eras recordatlas.org/context.jsonGET nothing the era contract, counts, quality gaps (v1.13.0) recordatlas.org/providers.jsonGET nothing 2,348 archives and sites, with access class recordatlas.org/given-names.json · surname-families.jsonGET nothing every form of a name (CC0) recordatlas.org/flag-index.json · era-flags.json · flag-eras.jsonGET nothing flags by country and era recordatlas.org/research-sessions.jsonGET nothing what the family archives have published https://api.recordatlas.org/v1/given-name/<name>GET nothing forms of a given name by language https://api.recordatlas.org/v1/term?q=&record= · /v1/date?text=GET nothing register words · date reading https://api.recordatlas.org/v1/providers?country=XX · /v1/contextGET nothing archives for a country · data build info https://api.recordatlas.org/mcpPOST nothing the same tools for AI assistants (see below) https://sync.recordatlas.org/v1/<id>PUT · GET · DELETE six words (tokens) save · fetch · erase your sealed research https://sync.recordatlas.org/v1/<id>/versions[/<day>]GET read token the last 30 daily copies https://sync.recordatlas.org/v1/countGET nothing how many people keep a copy https://ai.recordatlas.org/v1/translate · transcribe · document · casefilePOST Turnstile check, optional six-word id Claude reads a pasted line or photo; a few free tries a day https://ai.recordatlas.org/v1/allowanceGET optional id tries left today
Using it from an AI assistant
- 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. - Any other assistant that speaks MCP: point it at the same address (streamable HTTP, JSON replies).
- 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