# GBIF Species Taxonomy Scraper (`parseforge/gbif-species-scraper`) Actor

Scrapes GBIF species search by scientific name, keyword, or taxonomic rank. Returns each record as a flat row with the accepted name, taxonomic key, and rank.

- **URL**: https://apify.com/parseforge/gbif-species-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 89.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### GBIF Species Taxonomy Scraper

**Scrape GBIF species taxonomy records by scientific name, keyword, or taxonomic rank, up to a million per run.** Each record returns the accepted scientific name, taxonomic key, rank, and classification. No API key required. Export to JSON, CSV, Excel, or XML.

GBIF's official API requires understanding their complex query structure and rate limits. This actor reads the public species search directly, letting you query by common or scientific name and filter by taxonomic rank. It returns each matching species as a flat, structured row ready for analysis.

| Who uses it | What they scrape GBIF for |
|---|---|
| Biodiversity researchers | Compiling a checklist of accepted species names for a taxonomic group in a study area. |
| Conservation data managers | Validating and standardizing species names against the GBIF backbone taxonomy. |
| Bioinformatics developers | Building a local reference database of taxonomic keys and hierarchies for a specific clade. |
| Ecological consultants | Generating a species list for an environmental impact assessment from a keyword search. |

### What it does

This Actor collects GBIF species taxonomy records by scientific name, keyword, or rank filter, and returns each one as a flat row with its classification.

- 🔬 **Scientific name query:** Search by full or partial scientific name, such as 'Panthera tigris' or 'Panthera'.
- 🏷️ **Taxonomic rank filter:** Restrict results to a specific rank like Kingdom, Phylum, Class, Order, Family, Genus, Species, or Subspecies.
- 📋 **Flat structured output:** Every record arrives with the same schema, including taxonomic key, scientific name, and rank, ready for spreadsheets.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with GBIF data

**📋 Build a regional species checklist.**

A conservation manager searches for a genus and filters by the Species rank to produce a complete, validated list for a protected area management plan.

**🔗 Resolve scientific names to GBIF keys.**

A bioinformatician runs a list of scientific names through the scraper to match them against the GBIF backbone and retrieve their unique taxonomic keys for database linking.

**🧬 Gather all members of a taxonomic family.**

A researcher queries a family name and sets the rank filter to Genus to collect all constituent genera for a phylogenetic study.

**📊 Export taxonomy data for offline analysis.**

An ecologist pulls all species records for a given order and exports the structured data to CSV for statistical analysis in R or Python.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key** | Accesses the public GBIF species search without registration or authentication. |
| **Taxonomic backbone** | Returns the accepted scientific name and key from GBIF's authoritative taxonomy. |
| **Rank filtering** | Narrows results to a specific taxonomic level like Family or Genus before collection. |
| **Scalable collection** | Collects from a single record up to one million species per run. |

### How it compares

This actor focuses on a simple, fast species name and taxonomy search against the GBIF backbone, while other GBIF scrapers on Apify may include occurrence data or different output fields.

| Feature | ParseForge | Gbif Species Search List2 Scraper | GBIF Species & Occurrence Scraper - Biodiversity Data | Gbif Species Search Scraper |
|---|---|---|---|---|
| Search by scientific or common name | Yes | Not listed | Not listed | Not listed |
| Filter by taxonomic rank | Yes | Not listed | Not listed | Not listed |
| Collects occurrence records with coordinates | No, taxonomy only | Not listed | Yes | Not listed |
| Returns GBIF taxonomic key | Yes | Yes | Not listed | Yes |
| No API key required | Yes | Not listed | Yes | Not listed |

### Configure the run

Drive the Actor with a species name or keyword, and optionally restrict results to a single taxonomic rank. Filters apply as records are read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10
}
```

A larger pull:

```json
{
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.0085 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.85 |
| 1,000 results | $8.50 |
| 10,000 results | $85.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [GBIF Species Taxonomy Scraper](https://apify.com/parseforge/gbif-species-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to GBIF through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/gbif-species-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results for my query?**

Check the spelling of your scientific or common name. Try a shorter or more general keyword. Also, ensure the Rank filter is not set to a level that excludes your target, such as filtering for Species when searching for a Family name.

**The scraper is returning fewer records than my max items setting.**

This means your query matched fewer records in GBIF than the maximum you set. The scraper collects all available matches. Try broadening your search term or setting the Rank filter to 'Any'.

**I am getting a timeout or the run is taking too long.**

Reduce the maximum items to a smaller number. Very large queries can take time to process. Start with a small test run to verify your query, then scale up.

**The scientific name in the output looks different from what I searched.**

GBIF's species search may return the accepted scientific name for a synonym or a higher taxonomic match. The output reflects the canonical name from the GBIF backbone taxonomy.

**Can I search by GBIF taxon key directly?**

This actor is designed for text-based species name and keyword searches. Direct lookup by GBIF taxon key is not supported in the current input schema.

### FAQ

| Question | Answer |
|---|---|
| Do I need a GBIF account or API key to use this scraper? | No. This actor reads the public GBIF species search pages and does not require any registration, account, or API key. |
| What taxonomic information does each record contain? | Each record includes the accepted scientific name, the GBIF taxonomic key, and the taxonomic rank. The exact fields are shown in the sample output on the Actor's page. |
| Can I search by common name instead of scientific name? | Yes. The query field accepts both common names like 'tiger' and scientific names like 'Panthera tigris', matching against GBIF's species search. |
| How do I get only species-level results? | Set the Rank filter to 'Species' in the input configuration. The scraper will then return only records at that taxonomic level. |
| What is the maximum number of species I can collect in one run? | You can set the maximum up to 1,000,000 records per run. The default is 10, which is useful for testing your query. |
| Can I search for a partial scientific name? | Yes. Entering a partial name like 'Panthera' will return all species and other ranks that match that string in GBIF's search. |
| What export formats are supported? | You can export your collected dataset in JSON, CSV, Excel, or XML formats directly from the Apify platform. |
| Does this scraper get occurrence data or species taxonomy? | This actor focuses on the GBIF species taxonomy and checklist data. It does not collect occurrence records with geographic coordinates. |
| Is the data from the GBIF backbone taxonomy? | Yes. The records returned are from the GBIF backbone taxonomy, which provides a single, authoritative classification for biodiversity data. |
| Can I filter by taxonomic rank other than species? | Yes. You can filter by Kingdom, Phylum, Class, Order, Family, Genus, Species, or Subspecies using the Rank dropdown. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by GBIF Secretariat. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `query` (type: `string`):

Free-text species search query. Example: Panthera tigris. Leave empty for a general listing.

## `rank` (type: `string`):

Filter by taxonomic rank.

## `maxItems` (type: `integer`):

How many species to collect per run.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/gbif-species-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/gbif-species-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/gbif-species-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/gbif-species-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/QfQEAnX8NrifALTZ5/builds/pOZvDsW3C9SnmtVPp/openapi.json