gbif-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@gbif-mcp Find occurrence records for Panthera leo in Kenya"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
GBIF MCP Server
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:agentsThen 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 | yes |
2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05 | classic | 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/listis advertised as cacheable (ttlMs1 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: trueand 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 everywhereAgent | What the script does |
|
|
| adds |
|
|
|
|
| adds a |
| adds |
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 gbifUse --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.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonLinux:
~/.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 -dClaude 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:latestWith 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=serveA .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 |
| Full-text search of the taxonomic backbone with rank, status, habitat, threat and dataset filters |
| Full record for a taxon key |
| Fuzzy-match a scientific name to the backbone |
| Autocomplete name suggestions |
| Parse scientific names into their components |
| Direct taxonomic children |
| Full classification path |
| Sibling and related taxa under the same parent |
| Synonyms of a taxon |
| Common names by language |
| Textual descriptions |
| Geographic distributions |
| Images, sounds and videos |
| Occurrence statistics for a species: record, dataset and country counts, basis-of-record breakdown |
Occurrence (14)
Tool | Purpose |
| Search records with 40+ filters (taxon, country, coordinates, dates, basis of record, media, issues…) |
| A single interpreted record |
| The original, uninterpreted record |
| Count records matching a filter |
| Breakdown by basis of record |
| Breakdown by year |
| Breakdown by country |
| Breakdown by publishing country |
| Breakdown by dataset |
| Breakdown by species within a higher taxon |
| Breakdown by publishing organization |
| Build a download predicate from search filters |
| Request a download (needs credentials) |
| 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 |
| Datasets |
| Occurrence/quality metrics and the EML metadata document |
| Publishing organizations |
| Networks |
| Technical installations (IPTs etc.) |
| GBIF participant nodes |
| GRSciColl collections |
| 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.jsBoth 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 # PrettierProject 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 scriptAdding 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 toolsgbif_literature_getARead-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_literature_searchARead-onlyIdempotent
Search scientific literature that cites GBIF data. Find peer-reviewed publications, reports, and papers that used GBIF-mediated data. Useful for understanding data impact, finding research examples, and tracking biodiversity research trends.
Inputs: q, year, limit, offset, +5 more.
gbif_maps_get_raster_tile_urlARead-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_urlBRead-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_urlARead-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_stylesARead-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_countARead-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_recordARead-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_countryARead-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_datasetARead-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_countryARead-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_orgBRead-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_taxonARead-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_yearARead-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_builderBRead-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_statusARead-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_getARead-onlyIdempotent
Get complete details for a single occurrence record including verbatim fields, interpretation history, media, and data quality issues.
Inputs: key (required).
gbif_occurrence_searchARead-onlyIdempotent
Search GBIF occurrence records (species observations and specimens) with comprehensive filtering by taxonomy, geography, time, data quality, and more. Returns paginated results with optional facets for aggregations.
Inputs: q, year, depth, facet, +38 more.
gbif_occurrence_verbatimARead-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_documentARead-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_metricsARead-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_collectionARead-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_datasetARead-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_installationARead-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_institutionARead-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_networkARead-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_nodeARead-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_organizationARead-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_nodesARead-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_datasetsARead-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_datasetsBRead-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_collectionsARead-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_datasetsBRead-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_installationsARead-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_institutionsCRead-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_networksARead-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_organizationsBRead-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_childrenBRead-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_descriptionsARead-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_distributionsBRead-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_getBRead-onlyIdempotent
Get detailed information about a specific species by its GBIF key.
Inputs: key (required).
gbif_species_matchBRead-onlyIdempotent
Fuzzy match a species name against the GBIF backbone taxonomy.
Inputs: name (required), strict.
gbif_species_mediaARead-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_metricsARead-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_parentsARead-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_namesARead-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_searchBRead-onlyIdempotent
Search for species in the GBIF taxonomic backbone. Supports filtering by rank, status, habitat, threat level, and more.
Inputs: q, hl, rank, facet, +13 more.
gbif_species_suggestARead-onlyIdempotent
Get species name suggestions for autocomplete functionality.
Inputs: q (required), limit.
gbif_species_synonymsARead-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_namesBRead-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_statusARead-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_getARead-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_conceptARead-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_listARead-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
Scored across 58 tools
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.
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.
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.
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
Related MCP Connectors
Search GBIF species taxonomy, occurrence records, datasets, and publishers.
Search GBIF species taxonomy, occurrence records, datasets, and publishers.
GBIF MCP — wraps the Global Biodiversity Information Facility API v1 (free, no auth)
Search iNaturalist sightings, identification threads, phenology, and look-alike species.
Related MCP Servers
- AlicenseNot gradedqualityNot gradedmaintenanceEnables 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
- AlicenseNot gradedqualityCmaintenanceEnables querying biodiversity data from the Global Biodiversity Information Facility (GBIF) API v1, supporting species occurrence searches and other GBIF endpoints through natural language.79 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables querying a global plant database with over 1 million species, providing access to plant records and species search via natural language.83 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables 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 npmMIT