Open Tree of Life API

Free Open Tree of Life API with no key: match scientific names to taxonomy identifiers, resolve synonyms and fetch subtrees of the synthetic tree of life. Tested POST example included.

No API key requiredCORS enabledHTTPSFree tier

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

What is the Open Tree of Life API?

The Open Tree of Life API is a free, key-free REST service that matches scientific names against the Open Tree Taxonomy and returns matching taxa with their OTT identifiers, ranks, synonyms and nomenclatural codes. Further endpoints return subtrees and induced subtrees of the synthetic phylogeny.

Open Tree of Life stitches published phylogenetic trees together with a synthesised taxonomy to produce one tree covering every named organism. For most developers the useful part is not the tree at all but the name-matching service: taxonomy is full of homonyms, misspellings and synonyms, and TNRS — the taxonomic name resolution service — turns a messy list of names into stable OTT identifiers you can actually join on.

The matching endpoint is a POST that takes an array of names and returns one result block per name, each with candidate matches scored 0-1. Read the flags before trusting a match: `is_synonym` tells you the name you supplied is not the currently accepted one, `is_approximate_match` means fuzzy matching kicked in, and the taxon `flags` array can contain values like `extinct` or `sibling_higher` that materially change how you should treat the record. The service also infers a `context` from your batch — the example returns `Mammals` — which narrows the search space and reduces homonym collisions.

Quick facts

Base URL: https://api.opentreeoflife.org/v3
Authentication: No API key or account. Open Tree of Life releases its taxonomy and synthetic tree under CC0, so reuse including commercial reuse is unrestricted.
Rate limit: No published limit. Name matching accepts batches, so send one request with many names rather than many requests with one name each.
Pricing: Free. Data is CC0 public domain dedication.
CORS: Enabled — callable directly from browser JavaScript
Official docs: Read the docs

How to use the Open Tree of Life API

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

1. Match two scientific names to Open Tree taxonomy identifiers

POST https://api.opentreeoflife.org/v3/tnrs/match_names

curl

curl -X POST 'https://api.opentreeoflife.org/v3/tnrs/match_names' \
  -H 'Content-Type: application/json' \
  -d '{"names":["Homo sapiens","Panthera leo"]}'

JavaScript (fetch)

const res = await fetch("https://api.opentreeoflife.org/v3/tnrs/match_names", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"names":["Homo sapiens","Panthera leo"]}),
});
if (!res.ok) throw new Error(`Request failed: ${res.status}`);
const data = await res.json();
console.log(data);

Python (requests)

import requests

headers = {
    "Content-Type": "application/json",
}

payload = {"names":["Homo sapiens","Panthera leo"]}

res = requests.post("https://api.opentreeoflife.org/v3/tnrs/match_names", headers=headers, json=payload, timeout=20)
res.raise_for_status()
print(res.json())

Response — HTTP 200 (truncated)

{
  "context": "Mammals",
  "governing_code": "ICZN",
  "includes_approximate_matches": false,
  "includes_deprecated_taxa": false,
  "includes_suppressed_names": false,
  "matched_names": [
    "Homo sapiens",
    "Panthera leo"
  ],
  "results": [
    {
      "matches": [
        {
          "is_approximate_match": false,
          "is_synonym": false,
          "matched_name": "Homo sapiens",
          "nomenclature_code": "ICZN",
          "score": 1.0,
          "search_string": "homo sapiens",
          "taxon": {
            "flags": [
              "extinct",
              "sibling_higher"
            ],
            "is_suppressed": false,
            "is_suppressed_from_synth": false,
            "name": "Homo sapiens",
            "ott_id": 770315,
            "rank": "species",
            "source": "ott3.7draft3",
            "synonyms": [
              "Homo aethiopicus",
              "Homo americanus",
              "Homo arabicus",
              "Homo aurignacensis",
              "Homo australasicus",
              "Homo cafer",
              "Homo capensis",
              "Homo columbicus",
              "Homo cro-magnonensis",
              "Homo dawsoni",
              "Homo drennani",
              "Homo eurafricanus",
              "Homo floresiensis",
              "Homo fossilis protoaethiopicus",
              "Homo grimaldiensis",
              "Homo grimaldii",
              "Homo helmei",
              "Homo hottentotus",
              "Homo hyperboreus",
              "Homo indicus",
              "Homo japeticus",
              "Homo kanamensis

Parameters

Parameter	Type	Required	Description
`names`	body field	Required	Array of scientific names to match. Batch them — the endpoint is designed for lists. `["Homo sapiens","Panthera leo"]`
`context_name`	body field	Optional	Restrict matching to a taxonomic context such as `Mammals` or `Aves`. Inferred automatically when omitted. `Mammals`
`do_approximate_matching`	body field	Optional	Enable fuzzy matching for misspellings. Defaults to true; turn it off for strict validation. `false`
`include_suppressed`	body field	Optional	Include taxa suppressed from the synthetic tree, such as environmental samples. `false`

Response fields

contextstring: The taxonomic context the service inferred or you supplied. Wrong context is a common source of bad matches.
matched_namesarray: The subset of submitted names that matched something. Compare against your input to find failures.
results[].matches[].scorefloat: Match confidence, 0-1. Exact matches score 1.0.
results[].matches[].is_synonymboolean: True when the name you supplied is a synonym of the accepted taxon returned.
results[].matches[].is_approximate_matchboolean: True when the match required fuzzy string comparison — always review these by hand.
taxon.ott_idinteger: The Open Tree Taxonomy identifier, which is the stable key for every other endpoint.
taxon.flagsarray: Status flags such as `extinct`, `incertae_sedis` or `sibling_higher` that qualify how the taxon sits in the tree.

What you can build with the Open Tree of Life API

Clean a messy species list down to accepted names and stable identifiers
Detect synonyms and misspellings in field or collection data
Fetch the induced subtree connecting a set of species
Join biodiversity datasets that use different taxonomic authorities
Check whether a taxon is extinct or of uncertain placement before analysis

Common errors and how to fix them

400

The POST body was not valid JSON, or `names` was a bare string.

Fix: `names` must be an array even for one name, and the request needs `Content-Type: application/json`.

Empty matches for a valid name

The inferred context excluded it.

Fix: Set `context_name` explicitly, or pass `context_name: "All life"` when your list spans kingdoms.

Multiple matches returned

The name is a homonym across taxonomic codes.

Fix: Use `nomenclature_code` and the inferred context to disambiguate; a plant and an animal can legitimately share a genus name.

Wrong species matched

Approximate matching accepted a near-miss.

Fix: Check `is_approximate_match` and `score`, and disable `do_approximate_matching` when you want strict validation rather than best-effort cleanup.

Open Tree of Life API — frequently asked questions

Is the Open Tree of Life API free?

Yes, with no key or registration, and the data is released under CC0 so you can reuse it without restriction. The project asks for citation as academic courtesy.

What is an OTT id?

It is the Open Tree Taxonomy identifier, a stable integer key for a taxon that every other Open Tree endpoint accepts. Resolving names to OTT ids once and working with the ids afterwards avoids all the ambiguity of species names.

How does this differ from GBIF or Catalogue of Life?

Open Tree's taxonomy exists to support a phylogeny, so it merges several source taxonomies and is explicit about uncertain placement. GBIF is occurrence-focused and Catalogue of Life is a curated checklist. For name matching they overlap heavily; for asking what is related to what, only Open Tree gives you a tree.

Can I get the actual phylogenetic tree?

Yes. The `/tree_of_life/subtree` and `/tree_of_life/induced_subtree` endpoints return Newick or JSON trees given OTT ids, which is the usual second step after name matching.

Tools that pair with this API

JSON Formatter

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

JSON to CSV Converter

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

Text Compare

Compare two texts online free and highlight every difference. A private text comparison tool that finds matches and changes right in your browser.

Open Tree of Life is an independent third-party service and is not affiliated with ByteTools or ByteVancer. Details on this page were verified on 2026-08-21; always check the official documentation before relying on this API in production, as terms and limits can change.