Skip to main content
Glama

GBIF MCP Server

MCP 2026-07-28 Node 20+ 58 tools License: CC BY 4.0

A Model Context Protocol server that gives AI assistants programmatic access to the Global Biodiversity Information Facility (GBIF) API: species taxonomy, 2+ billion occurrence records, datasets and publishers, map tiles, literature citing GBIF data, controlled vocabularies and data validation.

Works with Claude Code, Claude Desktop, OpenAI Codex CLI, Gemini CLI, Goose, OpenCode and any other MCP client that can launch a stdio server.

Quick start

git clone https://github.com/idss-mesa/gbif-mcp.git
cd gbif-mcp
npm install
npm run build

# Register the server with every supported agent found on this machine
npm run install:agents

Then ask your assistant something like "Search GBIF for Panthera leo occurrences in Kenya".

Requires Node.js 20 or newer. GBIF credentials are optional and only needed for occurrence download requests (see Configuration).

Related MCP server: mcp-gbif

Contents

Protocol support

The server implements MCP protocol revision 2026-07-28 through the v2 TypeScript SDK (@modelcontextprotocol/server). Each connection is served in whichever era the client speaks:

Client

Handshake

Served

2026-07-28

per-request _meta envelope, optional server/discover probe

yes

2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05

classic initialize

yes (default)

Current Claude Desktop and Claude Code builds still use the initialize handshake and work without any configuration change. Set MCP_LEGACY_CLIENTS=reject to accept 2026-07-28 clients only; older clients then receive error -32022 (unsupported protocol version).

Other 2026-07-28 details:

  • tools/list is advertised as cacheable (ttlMs 1 hour, cacheScope: public).

  • Every tool carries annotations (readOnlyHint, idempotentHint, openWorldHint). Only the download and validator tools, which create jobs on GBIF, are marked non-read-only.

  • Tool arguments are validated against the advertised JSON Schema before execution. Invalid arguments and unknown tools return JSON-RPC error -32602.

  • Failed GBIF calls come back as tool results with isError: true and a JSON error envelope, never as a crashed connection.

  • ping, logging/setLevel, sampling, roots and elicitation are not used. Logs go to stderr.

  • The process exits when the client closes stdin, so no orphaned servers are left behind.

Installation

Install script

scripts/install.sh registers the server with every supported agent it finds. It builds the server if build/index.js is missing, prefers each agent's own CLI when one is installed (claude mcp add, codex mcp add, gemini mcp add) and otherwise merges an entry into the agent's config file, keeping everything else in the file and leaving a .bak copy.

npm run install:agents                           # every agent detected on this machine
scripts/install.sh --agents all --dry-run        # preview the change for every agent
scripts/install.sh --agents claude,goose         # just Claude Code and Goose
scripts/install.sh --scope project               # project-level config (claude, codex, gemini, opencode)
scripts/install.sh --username you --password …   # store GBIF credentials for download requests
scripts/install.sh --env LOG_LEVEL=debug         # any extra environment variable
scripts/install.sh --uninstall                   # remove the registration everywhere

Agent

What the script does

claude (Claude Code)

claude mcp add --scope user gbif -- node build/index.js

claude-desktop

adds mcpServers.gbif to claude_desktop_config.json (macOS / Linux paths)

codex (OpenAI Codex CLI)

codex mcp add gbif -- node build/index.js, or a [mcp_servers.gbif] table in ~/.codex/config.toml

gemini (Gemini CLI)

gemini mcp add --scope user gbif node build/index.js, or mcpServers.gbif in ~/.gemini/settings.json

goose

adds a gbif stdio extension to ~/.config/goose/config.yaml

opencode

adds mcp.servers.gbif (v2) or mcp.gbif (v1) to ~/.config/opencode/opencode.json

The script writes absolute paths for node and build/index.js, because desktop apps do not inherit your shell PATH. It needs bash and Node.js 20+. On Windows run it from WSL or Git Bash, or follow the manual steps below. Restart desktop apps (Claude Desktop, Goose Desktop) after installing.

Claude Code

cd /path/to/gbif-mcp
claude mcp add gbif -- node "$(pwd)/build/index.js"

# with GBIF credentials for download requests
claude mcp add gbif -e GBIF_USERNAME=you -e GBIF_PASSWORD=secret -- node "$(pwd)/build/index.js"

claude mcp list        # shows gbif with a health check
claude mcp get gbif    # details and connection status
claude mcp remove gbif

Use --scope project to write the entry to .mcp.json in the current repository instead of your user config.

Claude Desktop

Add the server to the configuration file and restart Claude Desktop:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

  • Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "gbif": {
      "command": "node",
      "args": ["/ABSOLUTE/PATH/TO/gbif-mcp/build/index.js"],
      "env": {
        "GBIF_USERNAME": "optional-username",
        "GBIF_PASSWORD": "optional-password"
      }
    }
  }
}

Use absolute paths (not ~/ or ./). On Windows escape backslashes: "C:\\Users\\You\\gbif-mcp\\build\\index.js". If node is not found, replace "command": "node" with the full path printed by which node (or where node on Windows).

Codex CLI, Gemini CLI, Goose, OpenCode

The install script handles all four. The equivalent manual entries are:

# ~/.codex/config.toml
[mcp_servers.gbif]
command = "node"
args = ["/ABSOLUTE/PATH/TO/gbif-mcp/build/index.js"]
// ~/.gemini/settings.json
{ "mcpServers": { "gbif": { "command": "node", "args": ["/ABSOLUTE/PATH/TO/gbif-mcp/build/index.js"] } } }
# ~/.config/goose/config.yaml
extensions:
  gbif:
    enabled: true
    type: stdio
    name: gbif
    cmd: node
    args: ["/ABSOLUTE/PATH/TO/gbif-mcp/build/index.js"]
    envs: {}
    timeout: 300
// ~/.config/opencode/opencode.json (OpenCode v2; v1 uses "mcp": { "gbif": … })
{ "mcp": { "servers": { "gbif": { "type": "local", "command": ["node", "/ABSOLUTE/PATH/TO/gbif-mcp/build/index.js"], "enabled": true } } } }

Any other MCP client that can launch a stdio command works the same way: node /ABSOLUTE/PATH/TO/gbif-mcp/build/index.js.

Docker

docker build -t gbif-mcp:latest .
docker run -i --rm gbif-mcp:latest            # stdio: keep -i, never -d

Claude Desktop / any JSON-configured client:

{
  "mcpServers": {
    "gbif": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "GBIF_USERNAME=you", "-e", "GBIF_PASSWORD=secret", "gbif-mcp:latest"]
    }
  }
}

Claude Code:

claude mcp add gbif -- docker run -i --rm gbif-mcp:latest

With Docker Compose, build with docker compose build and point the client at docker compose run --rm gbif-mcp. The image is a multi-stage Node 20 Alpine build (about 150 MB) that runs as a non-root user on a read-only root filesystem.

Configuration

All settings are environment variables. Defaults are shown; nothing is required.

# GBIF credentials (only for occurrence download requests)
GBIF_USERNAME=
GBIF_PASSWORD=

# GBIF API
GBIF_BASE_URL=https://api.gbif.org/v1
GBIF_USER_AGENT=GBIF-MCP-Server/1.1.0
GBIF_TIMEOUT=30000

# Rate limiting and caching
RATE_LIMIT_MAX_REQUESTS=100
RATE_LIMIT_CONCURRENT=10
CACHE_ENABLED=true
CACHE_MAX_SIZE=100
CACHE_TTL=3600000

# Response size limits (see below)
RESPONSE_MAX_SIZE_KB=250
RESPONSE_WARN_SIZE_KB=200
RESPONSE_ENABLE_TRUNCATION=true
RESPONSE_ENABLE_SIZE_LOGGING=true

# Logging (stderr; stdout is reserved for the protocol)
LOG_LEVEL=info          # error | warn | info | debug
LOG_FORMAT=json

# MCP protocol: serve (also accept 2025-era `initialize` clients) or reject
MCP_LEGACY_CLIENTS=serve

A .env file in the project root is read during local development.

Available tools

58 tools across seven GBIF API sections. Every parameter carries a description, valid values and a real example value (for instance taxonKey: 212 for family Felidae), so assistants can build correct queries without guessing. Results are paginated with offset/limit and an endOfRecords flag.

Species (14)

Tool

Purpose

gbif_species_search

Full-text search of the taxonomic backbone with rank, status, habitat, threat and dataset filters

gbif_species_get

Full record for a taxon key

gbif_species_match

Fuzzy-match a scientific name to the backbone

gbif_species_suggest

Autocomplete name suggestions

gbif_species_parse_names

Parse scientific names into their components

gbif_species_children

Direct taxonomic children

gbif_species_parents

Full classification path

gbif_species_related

Sibling and related taxa under the same parent

gbif_species_synonyms

Synonyms of a taxon

gbif_species_vernacular_names

Common names by language

gbif_species_descriptions

Textual descriptions

gbif_species_distributions

Geographic distributions

gbif_species_media

Images, sounds and videos

gbif_species_metrics

Occurrence statistics for a species: record, dataset and country counts, basis-of-record breakdown

Occurrence (14)

Tool

Purpose

gbif_occurrence_search

Search records with 40+ filters (taxon, country, coordinates, dates, basis of record, media, issues…)

gbif_occurrence_get

A single interpreted record

gbif_occurrence_verbatim

The original, uninterpreted record

gbif_occurrence_count

Count records matching a filter

gbif_occurrence_counts_by_basis_of_record

Breakdown by basis of record

gbif_occurrence_counts_by_year

Breakdown by year

gbif_occurrence_counts_by_country

Breakdown by country

gbif_occurrence_counts_by_publishing_country

Breakdown by publishing country

gbif_occurrence_counts_by_dataset

Breakdown by dataset

gbif_occurrence_counts_by_taxon

Breakdown by species within a higher taxon

gbif_occurrence_counts_by_publishing_org

Breakdown by publishing organization

gbif_occurrence_download_predicate_builder

Build a download predicate from search filters

gbif_occurrence_download_request

Request a download (needs credentials)

gbif_occurrence_download_status

Check a download's status

The "counts by" tools use GBIF faceted search, so every filter of gbif_occurrence_search applies to them.

Registry (18)

Tool

Purpose

gbif_registry_search_datasets, gbif_registry_get_dataset

Datasets

gbif_registry_dataset_metrics, gbif_registry_dataset_document

Occurrence/quality metrics and the EML metadata document

gbif_registry_search_organizations, gbif_registry_get_organization, gbif_registry_organization_datasets

Publishing organizations

gbif_registry_search_networks, gbif_registry_get_network, gbif_registry_network_datasets

Networks

gbif_registry_search_installations, gbif_registry_get_installation

Technical installations (IPTs etc.)

gbif_registry_list_nodes, gbif_registry_get_node

GBIF participant nodes

gbif_registry_search_collections, gbif_registry_get_collection

GRSciColl collections

gbif_registry_search_institutions, gbif_registry_get_institution

GRSciColl institutions

Maps (4)

gbif_maps_get_tile_url, gbif_maps_get_raster_tile_url, gbif_maps_get_vector_tile_url, gbif_maps_list_styles. These build GBIF map tile URLs (density maps of occurrences for any search filter) rather than returning image bytes.

Literature (2)

gbif_literature_search (papers citing GBIF-mediated data, with topic, year, dataset, peer-review and open-access filters) and gbif_literature_get (one paper by DOI).

Vocabularies (3)

gbif_vocabularies_list, gbif_vocabularies_get, gbif_vocabularies_get_concept for GBIF's controlled vocabularies (LifeStage, Sex, BasisOfRecord, …).

Validator (3)

gbif_validator_validate_dwca, gbif_validator_validate_tabular (submit a Darwin Core archive or a CSV/TSV file for validation) and gbif_validator_get_status.

The full reference with every parameter is in TOOLS.md and under docs/api-reference.

Usage examples

Once a client is connected, ask in plain language:

  • "Search for occurrence records of Panthera tigris in India since 2020."

  • "What is the GBIF backbone key for Quercus robur, and what are its common names in German?"

  • "How many bird observations were recorded in California in 2023, broken down by month?"

  • "Find preserved orchid specimens collected before 1900 that have images."

  • "Which datasets does the Natural History Museum publish, and which is the largest?"

  • "Show me recent papers that used GBIF data on pollinators."

  • "Give me a map tile URL for all Apis mellifera records in Europe."

Response size limits

To fit AI context windows the server limits every tool result to 250 KB by default (RESPONSE_MAX_SIZE_KB). For paginated GBIF responses it keeps as many results as fit and adds pagination guidance; for other responses it returns metadata only. A truncated result looks like:

{
  "truncated": true,
  "originalSize": "1.2MB",
  "returnedSize": "248KB",
  "metadata": { "totalCount": 1000, "returnedCount": 23 },
  "pagination": {
    "suggestion": "Use limit=20 with offset=0, then offset=20, offset=40...",
    "example": { "taxonKey": 212, "limit": 20, "offset": 0 }
  },
  "data": { "...": "..." }
}

Set RESPONSE_ENABLE_TRUNCATION=false to disable it.

Verifying the server

From Claude Code, claude mcp list runs a health check and should show gbif as connected. To exercise the stdio surface directly:

npm run build

# 2026-07-28 client: every request carries the protocol envelope in _meta
echo '{"jsonrpc":"2.0","id":1,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{},"io.modelcontextprotocol/clientInfo":{"name":"manual","version":"0"}}}}' \
  | node build/index.js

# 2025-era client: classic initialize handshake, then tools/list
printf '%s\n%s\n%s\n' \
  '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"manual","version":"0"}}}' \
  '{"jsonrpc":"2.0","method":"notifications/initialized"}' \
  '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' \
  | node build/index.js

Both commands print JSON-RPC responses on stdout and exit once stdin closes.

Troubleshooting

Server does not connect. Check that build/index.js exists, that the config uses absolute paths, and that node --version reports 20 or newer. Claude Desktop logs live in ~/Library/Logs/Claude/ (macOS) or %APPDATA%\Claude\logs\ (Windows). In Claude Code, claude mcp get gbif shows the connection status and claude mcp remove gbif followed by claude mcp add re-registers it.

node: command not found from a desktop app. Desktop apps do not read your shell profile. Use the full path to node as the command, which is what the install script does.

401 on download requests. Downloads need a GBIF account. Set GBIF_USERNAME and GBIF_PASSWORD in the server's env; everything else works anonymously.

Rate limiting or slow responses. Use the count and "counts by" tools before large searches, keep limit small, and use an occurrence download for anything beyond a few thousand records. The client retries 5xx and 429 answers with backoff and opens a circuit breaker after repeated service failures; 404s for unknown keys do not count.

Docker. Always run with -i (and usually --rm); never -d, since MCP needs the stdio connection. Pass credentials with -e or --env-file.

Build errors. rm -rf build node_modules && npm install && npm run build, then npm run typecheck to see TypeScript diagnostics.

Development

npm run dev                         # run from source with tsx, watch mode
npm run build                       # compile to build/
npm run typecheck                   # tsc --noEmit
npm run test:unit                   # unit tests (GBIF API mocked with MSW)
npm run test:integration:protocol   # stdio conformance: 2026-07-28 + legacy clients, official v2 client
npm run test:integration:api        # adversarial matrix: every tool against the live GBIF API
npm run test:coverage               # coverage report
npm run format                      # Prettier

Project layout:

src/
  index.ts            GBIFMCPServer: McpServer factory, serveStdio, tool dispatch, shutdown
  core/gbif-client.ts HTTP client: queue, rate limit, LRU cache, retries, circuit breaker
  services/           one service per GBIF API section
  tools/              58 tools, one class each, Zod input schemas → JSON Schema
  protocol/           error formatting, correlation IDs
  utils/              response truncation, logging
tests/
  unit/               mirrors src/
  integration/mcp/    protocol tests (stdio-protocol.test.ts spawns the real server)
  integration/api/    live GBIF tests, including all-tools.integration.test.ts
scripts/install.sh    agent registration script

Adding a GBIF endpoint: write the service method, add a BaseTool subclass under src/tools/<section>/, export it from that folder's index.ts, register it in initializeServices() in src/index.ts, and add a case to the adversarial matrix. See CLAUDE.md for conventions.

Resources

Contributing

Issues and pull requests are welcome. Fork the repository, create a branch, add tests for service or tool changes (unit plus a line in the adversarial matrix), and open a pull request.

License

Creative Commons Attribution 4.0 International (CC BY 4.0).

GBIF data accessed through this server is subject to the licence of each dataset; see GBIF's data use terms.

Available Tools

58 tools
gbif_literature_getA
Read-onlyIdempotent

Get complete metadata for a scientific publication by its DOI. Returns title, authors, abstract, journal, citation info, and GBIF usage details. Use to get full details about a specific paper that used GBIF data.

Inputs: doi (required).

gbif_maps_get_raster_tile_urlA
Read-onlyIdempotent

Generate URL for pre-rendered PNG density map tiles. Raster tiles show occurrence density with various color schemes. Fast rendering, ideal for simple map displays. Use for quick visualization without client-side rendering overhead.

Inputs: x (required), y (required), z (required), year, +4 more.

gbif_maps_get_tile_urlB
Read-onlyIdempotent

Generate a URL for occurrence map tiles with customizable styling and filters. Returns tile URLs in standard web Mercator projection (EPSG:3857) for use in web mapping applications, GIS software, or direct visualization.

Inputs: x (required), y (required), z (required), srs, +8 more.

gbif_maps_get_vector_tile_urlA
Read-onlyIdempotent

Generate URL for occurrence vector tiles in Mapbox Vector Tile (MVT) format. Vector tiles enable client-side styling, interactivity, and dynamic rendering. Ideal for web mapping libraries like Mapbox GL JS, Leaflet with vector tile plugins, or OpenLayers.

Inputs: x (required), y (required), z (required), year, +5 more.

gbif_maps_list_stylesA
Read-onlyIdempotent

List all available map visualization styles for occurrence tiles. Returns style names, descriptions, and types (density/point/poly). Use to discover visualization options before generating tile URLs with gbif_maps_get_tile_url.

Inputs: no named parameters.

gbif_occurrence_countA
Read-onlyIdempotent

Fast endpoint for counting occurrences matching filters without retrieving full records. Useful for statistics, dashboards, and filter validation before running full searches.

Inputs: q, year, issue, month, +15 more.

gbif_occurrence_counts_by_basis_of_recordA
Read-onlyIdempotent

Get occurrence counts broken down by basis of record type (observations, specimens, etc.). Returns a breakdown showing how many occurrences of each type match your filters. Essential for understanding dataset composition and data quality. Very fast - use for dashboards and quick statistics.

Inputs: year, country, taxonKey, datasetKey, +1 more.

gbif_occurrence_counts_by_countryA
Read-onlyIdempotent

Get occurrence counts broken down by country for geographic distribution analysis. Returns counts per country showing global distribution patterns. Essential for understanding species ranges, identifying data gaps by region, and prioritizing conservation efforts. Fast statistics endpoint.

Inputs: year, taxonKey, datasetKey, basisOfRecord, +1 more.

gbif_occurrence_counts_by_datasetA
Read-onlyIdempotent

Get occurrence counts broken down by contributing dataset. Identifies which datasets contribute most records for a given query. Essential for data attribution, understanding data sources, finding primary datasets for a taxon/region, and acknowledging data providers. Returns dataset UUIDs with counts.

Inputs: year, country, taxonKey, basisOfRecord, +1 more.

gbif_occurrence_counts_by_publishing_countryA
Read-onlyIdempotent

Get occurrence counts broken down by the country of the publishing organization. Shows which countries are contributing data, useful for understanding data provider distribution, identifying data collaboration opportunities, and analyzing global participation in GBIF. Different from occurrence country (where specimen was collected).

Inputs: year, country, taxonKey, datasetKey, +1 more.

gbif_occurrence_counts_by_publishing_orgB
Read-onlyIdempotent

Get occurrence counts broken down by publishing organization UUID. Identifies which institutions are contributing the most data for a query. Essential for data attribution, understanding institutional contributions, acknowledging data providers, and analyzing organizational participation. Returns organization UUIDs with occurrence counts.

Inputs: year, country, taxonKey, basisOfRecord, +1 more.

gbif_occurrence_counts_by_taxonA
Read-onlyIdempotent

Get occurrence counts broken down by species (GBIF backbone speciesKey) for taxonomic composition analysis. Returns counts per species within the filtered taxon, most frequent first (top 100). Useful for understanding biodiversity patterns, identifying dominant species, and analyzing taxonomic coverage within a higher taxon. Fast statistics for ecological analysis.

Inputs: year, country, taxonKey, datasetKey, +1 more.

gbif_occurrence_counts_by_yearA
Read-onlyIdempotent

Get occurrence counts broken down by year for temporal trend analysis. Returns year-by-year counts showing how observations have accumulated over time. Perfect for time series visualization, identifying data collection patterns, and understanding temporal coverage. Fast endpoint for dashboards.

Inputs: country, taxonKey, datasetKey, basisOfRecord, +1 more.

gbif_occurrence_download_predicate_builderB
Read-onlyIdempotent

Helper tool to build a download predicate from simple search parameters. Converts occurrence search filters into the complex predicate format required by the download API.

Inputs: year, country, geometry, taxonKey, +4 more.

gbif_occurrence_download_requestA

Request an asynchronous download for large occurrence datasets beyond pagination limits (100,000+ records). Returns a download key for checking status. REQUIRES AUTHENTICATION: Set GBIF_USERNAME and GBIF_PASSWORD environment variables.

Inputs: creator (required), format, predicate, sendNotification, +1 more.

gbif_occurrence_download_statusA
Read-onlyIdempotent

Check the status and retrieve metadata for an occurrence download request. Returns status, download link when ready, record count, and file size.

Inputs: downloadKey (required).

gbif_occurrence_getA
Read-onlyIdempotent

Get complete details for a single occurrence record including verbatim fields, interpretation history, media, and data quality issues.

Inputs: key (required).

gbif_occurrence_verbatimA
Read-onlyIdempotent

Get the original, unprocessed occurrence record as provided by the publisher, before GBIF interpretation. Includes all original Darwin Core fields with full URIs.

Inputs: key (required).

gbif_registry_dataset_documentA
Read-onlyIdempotent

Get the EML (Ecological Metadata Language) metadata document for a dataset. Returns structured XML metadata including dataset description, contacts, geographic/taxonomic/temporal coverage, methods, and project information. Essential for proper dataset citation, understanding data collection methods, and accessing complete metadata.

Inputs: key (required).

gbif_registry_dataset_metricsA
Read-onlyIdempotent

Get occurrence statistics and quality metrics for a dataset. Returns counts by basis of record, country, year, and data quality indicators. Useful for understanding dataset composition and coverage.

Inputs: key (required).

gbif_registry_get_collectionA
Read-onlyIdempotent

Get complete details for a specific scientific collection from GRSciColl. Returns collection metadata, institutional affiliation, specimen holdings, contacts, and preservation methods. Essential for understanding physical specimen repositories.

Inputs: key (required).

gbif_registry_get_datasetA
Read-onlyIdempotent

Get complete metadata for a specific GBIF dataset by its UUID. Returns full dataset details including title, description, contacts, endpoints, geographic/taxonomic coverage, and citation information.

Inputs: key (required).

gbif_registry_get_installationA
Read-onlyIdempotent

Get complete details for a specific IPT or data server installation. Returns technical endpoint information, hosting organization, and datasets served by this installation.

Inputs: key (required).

gbif_registry_get_institutionA
Read-onlyIdempotent

Get complete details for a specific scientific institution from GRSciColl. Returns institutional metadata, collections housed, contacts, addresses, and identifiers. Use to understand institution profiles and their collection holdings.

Inputs: key (required).

gbif_registry_get_networkA
Read-onlyIdempotent

Get complete details for a specific dataset network. Returns network metadata, constituent datasets, contacts, and description. Use to understand collaborative data initiatives and their scope.

Inputs: key (required).

gbif_registry_get_nodeA
Read-onlyIdempotent

Get complete details for a GBIF participant node. Returns node metadata, contacts, participation type, country information, and endorsement details. Use to understand national GBIF participation, governance structure, and institutional membership.

Inputs: key (required).

gbif_registry_get_organizationA
Read-onlyIdempotent

Get complete details for a specific data-publishing organization. Returns contacts, addresses, datasets published, endorsement status, and institutional information.

Inputs: key (required).

gbif_registry_list_nodesA
Read-onlyIdempotent

List GBIF participant nodes (national/organizational participants). Nodes represent countries or organizations that participate in GBIF governance and data sharing. Essential for understanding GBIF network structure, national participation, and institutional membership.

Inputs: limit, offset, country.

gbif_registry_network_datasetsA
Read-onlyIdempotent

List all constituent datasets within a specific network. Shows which datasets are part of a collaborative network. Useful for exploring thematic data collections like eBird observations or marine biodiversity networks.

Inputs: networkKey (required), limit, offset.

gbif_registry_organization_datasetsB
Read-onlyIdempotent

List all datasets published by a specific organization. Shows the complete catalog of datasets contributed by an institution. Useful for understanding an organization's data contributions and portfolio.

Inputs: organizationKey (required), type, limit, offset.

gbif_registry_search_collectionsA
Read-onlyIdempotent

Search the Global Registry of Scientific Collections (GRSciColl) for natural history collections. Find museum collections, herbaria, tissue collections, and other scientific collections worldwide. Use to discover physical specimen holdings and their metadata.

Inputs: q, city, code, limit, +3 more.

gbif_registry_search_datasetsB
Read-onlyIdempotent

Search for datasets in the GBIF registry. Find published datasets by type, keyword, publisher, geographic coverage, and taxonomic scope. Essential for discovering data sources and understanding dataset metadata.

Inputs: q, type, limit, decade, +5 more.

gbif_registry_search_installationsA
Read-onlyIdempotent

Search for IPT (Integrated Publishing Toolkit) installations in the GBIF network. IPTs are servers that host and publish biodiversity datasets. Use to find technical infrastructure and data hosting platforms.

Inputs: q, type, limit, offset.

gbif_registry_search_institutionsC
Read-onlyIdempotent

Search for scientific institutions in the Global Registry of Scientific Collections (GRSciColl). Find museums, herbaria, universities, and research institutions that house natural history collections worldwide.

Inputs: q, city, code, limit, +2 more.

gbif_registry_search_networksA
Read-onlyIdempotent

Search for dataset networks in GBIF. Networks are collaborative groups that organize related datasets (e.g., eBird, iNaturalist, Ocean Biodiversity Information System). Use to discover thematic data collections and partnerships.

Inputs: q, limit, offset, identifier.

gbif_registry_search_organizationsB
Read-onlyIdempotent

Search for data-publishing organizations in the GBIF network. Find museums, herbaria, research institutions, and other biodiversity data publishers. Use to discover data providers and understand institutional participation.

Inputs: q, limit, offset, country, +1 more.

gbif_species_childrenB
Read-onlyIdempotent

Get direct taxonomic children of a taxon (e.g., species under a genus, subspecies under a species). Useful for exploring taxonomy hierarchically.

Inputs: key (required), limit, offset.

gbif_species_descriptionsA
Read-onlyIdempotent

Get textual descriptions for a species from various sources. Includes morphological descriptions, habitat information, behavior, and other narrative content.

Inputs: key (required), limit, offset.

gbif_species_distributionsB
Read-onlyIdempotent

Get known geographic distribution records for a species. Includes information about occurrence status, establishment means, and locality details.

Inputs: key (required), limit, offset.

gbif_species_getB
Read-onlyIdempotent

Get detailed information about a specific species by its GBIF key.

Inputs: key (required).

gbif_species_matchB
Read-onlyIdempotent

Fuzzy match a species name against the GBIF backbone taxonomy.

Inputs: name (required), strict.

gbif_species_mediaA
Read-onlyIdempotent

Get associated multimedia records for a species including images, sounds, and videos. Returns URLs and metadata for media resources from various sources.

Inputs: key (required), limit, offset.

gbif_species_metricsA
Read-onlyIdempotent

Get quick occurrence statistics for a species without running full searches. Returns total occurrence count, dataset count, country count, and basis of record breakdown. Fast endpoint perfect for species profile pages, dashboards, and quick data availability checks.

Inputs: key (required).

gbif_species_parentsA
Read-onlyIdempotent

Get the complete taxonomic classification path from kingdom down to the specified taxon. Returns the full hierarchy including all parent taxa. Useful for breadcrumb navigation and understanding taxonomic position.

Inputs: key (required).

gbif_species_parse_namesA
Read-onlyIdempotent

Parse and standardize scientific names in batch using GBIF's name parser. Extracts genus, species, authorship, rank, and more from scientific name strings. Essential for data cleaning, quality checking, and standardizing names from spreadsheets or databases. Handles up to 1000 names per request.

Inputs: names (required).

gbif_species_suggestA
Read-onlyIdempotent

Get species name suggestions for autocomplete functionality.

Inputs: q (required), limit.

gbif_species_synonymsA
Read-onlyIdempotent

Get all synonyms and alternative scientific names for a species. Useful for name resolution and historical name tracking.

Inputs: key (required), limit, offset.

gbif_species_vernacular_namesB
Read-onlyIdempotent

Get vernacular (common) names for a species in multiple languages. Returns preferred names when available.

Inputs: key (required), limit, offset, language.

gbif_validator_get_statusA
Read-onlyIdempotent

Check the status of an asynchronous Darwin Core Archive validation job. Validation is processed asynchronously, so use this tool to poll for completion and retrieve results. Returns validation status, progress, and results when complete.

Inputs: validationKey (required).

gbif_validator_validate_dwcaA

Validate a Darwin Core Archive (DwC-A) file against GBIF standards. Checks data structure, required fields, data quality, and format compliance. Returns validation report with issues, warnings, and recommendations. Essential before publishing datasets to GBIF.

Inputs: fileUrl (required).

gbif_validator_validate_tabularB

Validate tabular data files (CSV, TSV) against Darwin Core standards before creating archives. Checks column headers, data types, required fields, and format compliance. Useful for data preparation workflows, pre-publication validation, and quality assurance before creating Darwin Core Archives. Returns validation report with field-level issues.

Inputs: fileUrl (required), fileType.

gbif_vocabularies_getA
Read-onlyIdempotent

Get a specific controlled vocabulary with all its concepts and definitions. Returns the complete vocabulary including all valid values, descriptions, and usage notes. Use to understand valid values for specific GBIF fields.

Inputs: name (required).

gbif_vocabularies_get_conceptA
Read-onlyIdempotent

Get detailed information about a specific concept within a controlled vocabulary. Returns the concept definition, usage notes, related terms, and examples. Use to understand the precise meaning and usage of specific vocabulary terms.

Inputs: concept (required), vocabulary (required).

gbif_vocabularies_listA
Read-onlyIdempotent

List all controlled vocabularies used in GBIF. Vocabularies define valid values for fields like basisOfRecord, establishmentMeans, occurrenceStatus, etc. Essential for understanding valid filter values and data standardization.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 58 tools

    Disambiguation4/5

    Domain prefixes (registry/species/occurrence/maps/literature/vocabularies/validator) make most tools clearly distinguishable, and the many counts_by_* tools are well-differentiated by facet. Minor ambiguity exists between gbif_maps_get_tile_url and gbif_maps_get_raster_tile_url, and between gbif_vocabularies_get vs gbif_vocabularies_get_concept vs gbif_vocabularies_list.

    Naming Consistency3/5

    A consistent gbif_<domain>_<action> prefix is maintained across all tools, but the action ordering is mixed: many use verb_noun (gbif_species_search, gbif_registry_search_datasets) while registry and maps add noun-first variants (gbif_registry_dataset_metrics, gbif_maps_get_tile_url). Still readable but not a single predictable pattern.

    Tool Count2/5

    58 tools is well above the 25-tool threshold and feels heavy even for a broad API. Redundant families like seven gbif_occurrence_counts_by_* tools and three near-identical tile-URL tools inflate the surface beyond what an agent can easily navigate.

    Completeness4/5

    Coverage is broad and coherent: full registry discovery, species taxonomy, occurrence search/counts/verbatim, async download workflow (request/status/predicate builder), vocabulary lookup, literature, map tiles, and validation. Gaps are minor — largely read-only with no mutation tools, which is expected for GBIF, but a few operation types are absent.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      Enables interaction with the Atlas of Living Australia API to search and access 152+ million biodiversity records. Supports occurrence searches, spatial queries, bulk data downloads, and taxonomic data retrieval through natural language.
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables querying biodiversity data from the Global Biodiversity Information Facility (GBIF) API v1, supporting species occurrence searches and other GBIF endpoints through natural language.
      79 npm
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables querying a global plant database with over 1 million species, providing access to plant records and species search via natural language.
      83 npm
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to search roughly 150 million digitized natural-history museum specimen records (plants, animals, fossils) from US collections, filtered by taxonomy and locality, and to retrieve the full normalized record for any single specimen by its uuid. It also returns taxonomic or geographic specimen counts grouped by a chosen field, optionally narrowed by the same filters, with no API key required.
      73 npm
      MIT