# iNaturalist Species & Observations Scraper (`crawlerbros/inaturalist-species-observations`) Actor

Scrape iNaturalist - the world's largest nature observation platform with 200M+ wildlife sightings. Search observations by species name, browse taxa, filter by location and date, find common species in a region. Completely free, no API key required.

- **URL**: https://apify.com/crawlerbros/inaturalist-species-observations.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Agents, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## iNaturalist Species & Observations Scraper

Scrape wildlife observation data from [iNaturalist](https://www.inaturalist.org) — the world's largest citizen-science nature platform with over 200 million verified wildlife sightings contributed by millions of naturalists worldwide.

### What can it do?

- **Search wildlife observations** by species name (common or scientific), with location, date, and quality filters
- **Search species/taxa** — find species by name with full taxonomic details
- **Browse observations by place** — get all observations from a specific country or region
- **Discover common species** — find the most-observed species in any location

No API key or authentication required — completely free to use.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | select | What to fetch: `searchObservations`, `searchTaxa`, `observationsByPlace`, `commonSpecies` |
| `taxonName` | text | Species common or scientific name (e.g. "eagle", "red fox", "Vulpes vulpes") |
| `placeName` | text | Country or region name (e.g. "United States", "California", "France") |
| `qualityGrade` | select | Filter by quality grade: `research`, `needs_id`, `casual`, `any` |
| `taxonGroup` | select | Filter by taxonomic group: birds, mammals, insects, plants, etc. |
| `yearFrom` | integer | Start year for date filter (default: 2020) |
| `yearTo` | integer | End year for date filter (default: 2024) |
| `maxItems` | integer | Maximum records to return, 1–500 (default: 50) |

### Output — Observations

| Field | Description |
|-------|-------------|
| `observationId` | Unique iNaturalist observation ID |
| `speciesName` | Scientific species name (e.g. "Vulpes vulpes") |
| `commonName` | Common name (e.g. "Red Fox") |
| `taxonGroup` | Broad taxonomic group (Aves, Mammalia, Insecta, etc.) |
| `taxonRank` | Taxonomic rank (species, genus, family, etc.) |
| `taxonId` | iNaturalist taxon ID |
| `latitude` | Observation latitude |
| `longitude` | Observation longitude |
| `placeName` | Human-readable place name |
| `observedOn` | Date the organism was observed (YYYY-MM-DD) |
| `qualityGrade` | Quality grade: research, needs_id, or casual |
| `observerName` | Username of the observer |
| `imageUrl` | URL to observation photo |
| `mapsUrl` | Link to the observation page on iNaturalist |
| `wikipediaUrl` | Wikipedia article for the species (when available) |
| `scrapedAt` | ISO 8601 timestamp of when the record was scraped |

### Output — Taxa (searchTaxa mode)

| Field | Description |
|-------|-------------|
| `taxonId` | iNaturalist taxon ID |
| `name` | Scientific name |
| `commonName` | Common/preferred name |
| `rank` | Taxonomic rank |
| `taxonGroup` | Iconic taxon group |
| `observationsCount` | Total observations on iNaturalist |
| `ancestorIds` | Array of ancestor taxon IDs |
| `imageUrl` | Representative species photo URL |
| `wikipediaUrl` | Wikipedia article URL |
| `taxonPageUrl` | iNaturalist taxon page URL |
| `scrapedAt` | ISO 8601 timestamp |

### Output — Common Species (commonSpecies mode)

Same as taxa output, with an additional `queryPlace` field (the input place name) and `observationsCount` showing observation frequency in that location.

### Example Use Cases

- Track wildlife populations in specific regions
- Build species distribution maps
- Research invasive species observations
- Monitor rare or endangered species sightings
- Compile biodiversity reports by region or taxon group

### Modes

#### searchObservations (default)
Search for observations of a specific species across the globe. Filter by quality grade, taxon group, and date range.

**Example:** Find all research-grade red fox observations from 2022–2024
```json
{
  "mode": "searchObservations",
  "taxonName": "red fox",
  "qualityGrade": "research",
  "yearFrom": 2022,
  "yearTo": 2024,
  "maxItems": 50
}
````

#### searchTaxa

Look up species and taxonomic groups by name. Returns full taxonomic details including observation counts and Wikipedia links.

**Example:** Find all eagle species

```json
{
  "mode": "searchTaxa",
  "taxonName": "eagle",
  "taxonGroup": "Aves",
  "maxItems": 30
}
```

#### observationsByPlace

Get observations from a specific country or region. Useful for geographic biodiversity research.

**Example:** Bird observations in France

```json
{
  "mode": "observationsByPlace",
  "placeName": "France",
  "taxonGroup": "Aves",
  "qualityGrade": "research",
  "maxItems": 100
}
```

#### commonSpecies

Find the most frequently observed species in any location. Great for understanding local biodiversity.

**Example:** Top mammals in California

```json
{
  "mode": "commonSpecies",
  "placeName": "California",
  "taxonGroup": "Mammalia",
  "maxItems": 50
}
```

### Quality Grades

- **research** — Observations verified by community agreement; highest accuracy
- **needs\_id** — Submitted but awaiting identification confirmation
- **casual** — Missing location data, date, or other required fields
- **any** — Include all quality grades

### Supported Taxon Groups

Birds (Aves), Mammals (Mammalia), Insects (Insecta), Reptiles (Reptilia), Amphibians (Amphibia), Plants (Plantae), Fungi, Fish (Actinopterygii), Mollusks (Mollusca), Arachnids (Arachnida)

### FAQs

**Do I need an API key?**
No. The iNaturalist API is completely free for read-only access. No registration required.

**How many results can I get?**
Up to 500 per run. iNaturalist has millions of observations, so filters (taxon name, place, date range, quality grade) help narrow results.

**What is "research grade"?**
Research grade observations have been confirmed by at least two independent identifiers on iNaturalist, making them the most reliable for scientific use.

**Can I get data for a specific country?**
Yes — use `observationsByPlace` mode with a country name like "Germany" or "Brazil", or use `commonSpecies` to find the top species in that country.

**Are the photos freely available?**
Photo availability depends on each contributor's license. Check the `mapsUrl` link for full attribution details.

**What's the data coverage?**
iNaturalist has observations from all countries with over 200 million records, the majority research-grade from community verification.

# Actor input Schema

## `mode` (type: `string`):

What to fetch from iNaturalist.

## `taxonName` (type: `string`):

Common or scientific name to search for (e.g. 'eagle', 'rose', 'Vulpes vulpes'). Used in searchObservations and searchTaxa modes.

## `placeName` (type: `string`):

Country or region name to filter observations by location (e.g. 'United States', 'California', 'France'). Used in observationsByPlace and commonSpecies modes.

## `qualityGrade` (type: `string`):

Filter observations by quality grade. 'research' means identifications agreed by multiple observers.

## `taxonGroup` (type: `string`):

Filter to a broad taxonomic group. Leave blank for all groups.

## `yearFrom` (type: `integer`):

Only include observations from this year onwards.

## `yearTo` (type: `integer`):

Only include observations up to and including this year.

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

Maximum number of records to return (1â€“500).

## Actor input object example

```json
{
  "mode": "searchObservations",
  "taxonName": "red fox",
  "qualityGrade": "research",
  "taxonGroup": "",
  "yearFrom": 2020,
  "yearTo": 2025,
  "maxItems": 30
}
```

# Actor output Schema

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

Dataset containing all scraped iNaturalist observations or taxa records.

# 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 = {
    "mode": "searchObservations",
    "taxonName": "red fox",
    "qualityGrade": "research",
    "taxonGroup": "",
    "yearFrom": 2020,
    "yearTo": 2025,
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/inaturalist-species-observations").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 = {
    "mode": "searchObservations",
    "taxonName": "red fox",
    "qualityGrade": "research",
    "taxonGroup": "",
    "yearFrom": 2020,
    "yearTo": 2025,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/inaturalist-species-observations").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "searchObservations",
  "taxonName": "red fox",
  "qualityGrade": "research",
  "taxonGroup": "",
  "yearFrom": 2020,
  "yearTo": 2025,
  "maxItems": 30
}' |
apify call crawlerbros/inaturalist-species-observations --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/inaturalist-species-observations",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iNaturalist Species & Observations Scraper",
        "description": "Scrape iNaturalist - the world's largest nature observation platform with 200M+ wildlife sightings. Search observations by species name, browse taxa, filter by location and date, find common species in a region. Completely free, no API key required.",
        "version": "1.0",
        "x-build-id": "t7gEOH52eBcgYdlrN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~inaturalist-species-observations/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-inaturalist-species-observations",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~inaturalist-species-observations/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-inaturalist-species-observations",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~inaturalist-species-observations/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-inaturalist-species-observations",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchObservations",
                            "searchTaxa",
                            "observationsByPlace",
                            "commonSpecies"
                        ],
                        "type": "string",
                        "description": "What to fetch from iNaturalist.",
                        "default": "searchObservations"
                    },
                    "taxonName": {
                        "title": "Species / taxon name",
                        "type": "string",
                        "description": "Common or scientific name to search for (e.g. 'eagle', 'rose', 'Vulpes vulpes'). Used in searchObservations and searchTaxa modes.",
                        "default": "eagle"
                    },
                    "placeName": {
                        "title": "Place / region name",
                        "type": "string",
                        "description": "Country or region name to filter observations by location (e.g. 'United States', 'California', 'France'). Used in observationsByPlace and commonSpecies modes."
                    },
                    "qualityGrade": {
                        "title": "Quality grade",
                        "enum": [
                            "any",
                            "research",
                            "needs_id",
                            "casual"
                        ],
                        "type": "string",
                        "description": "Filter observations by quality grade. 'research' means identifications agreed by multiple observers.",
                        "default": "research"
                    },
                    "taxonGroup": {
                        "title": "Taxon group (iconic taxa)",
                        "enum": [
                            "",
                            "Aves",
                            "Mammalia",
                            "Insecta",
                            "Reptilia",
                            "Amphibia",
                            "Plantae",
                            "Fungi",
                            "Actinopterygii",
                            "Mollusca",
                            "Arachnida"
                        ],
                        "type": "string",
                        "description": "Filter to a broad taxonomic group. Leave blank for all groups.",
                        "default": ""
                    },
                    "yearFrom": {
                        "title": "Year from",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Only include observations from this year onwards.",
                        "default": 2020
                    },
                    "yearTo": {
                        "title": "Year to",
                        "minimum": 1900,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Only include observations up to and including this year.",
                        "default": 2025
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of records to return (1â€“500).",
                        "default": 50
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
