# iNaturalist Observations Scraper — Species & Biodiversity (`compute-edge/inaturalist-observations-scraper`) Actor

Extract species observations from the iNaturalist API. Get scientific and common names, taxon group, date, location with coordinates, quality grade, observer, and photos. Filter by taxon, place, and quality grade. Clean JSON for biodiversity research.

- **URL**: https://apify.com/compute-edge/inaturalist-observations-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.

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 Observations Scraper — Species & Biodiversity Data

Extract wildlife observation records from [iNaturalist](https://www.inaturalist.org/), the world's largest collaborative biodiversity database. Filter by **species name**, **taxon group**, **geographic place**, **quality grade**, and **date range**. Returns structured JSON with scientific name, common name, GPS coordinates, observer, and photo URL — ready for research, conservation analysis, or RAG pipelines.

**iNaturalist** hosts over 300 million observations contributed by naturalists, researchers, and citizen scientists worldwide. It is the primary data source for global biodiversity monitoring, invasive species tracking, and ecological research. Many observations carry research-grade verification from expert identifiers.

### Features

- Filter observations by species or taxon name (scientific or common)
- Filter by major taxon group: birds, plants, insects, mammals, reptiles, amphibians, fungi, and more
- Filter by iNaturalist place ID (country, state, national park, etc.)
- Filter by quality grade: `research`, `needs_id`, or `casual`
- Filter by observed date range (`dateFrom` / `dateTo`)
- Paginate through up to 10,000 results per query (iNaturalist API cap)
- Empty input returns recent observations across all taxa — works out of the box

### Data Fields

| Field | Description |
|-------|-------------|
| `id` | iNaturalist observation ID |
| `scientificName` | Accepted scientific name (e.g. `Danaus plexippus`) |
| `commonName` | Preferred common name (e.g. `Monarch Butterfly`) |
| `iconicTaxon` | Major group: Aves, Plantae, Insecta, Mammalia, etc. |
| `rank` | Taxonomic rank: species, genus, family, etc. |
| `observedOn` | Date of observation (YYYY-MM-DD) |
| `placeGuess` | Human-readable location string |
| `latitude` | Latitude (decimal degrees, null if obscured) |
| `longitude` | Longitude (decimal degrees, null if obscured) |
| `qualityGrade` | `research`, `needs_id`, or `casual` |
| `observer` | iNaturalist username of the observer |
| `url` | Direct link to the observation page |
| `photoUrl` | URL of the first observation photo (square thumbnail) |

### How to Scrape iNaturalist Observations

#### Step 1 — Open the Actor

Go to the [iNaturalist Observations Scraper](https://apify.com/seatsignal/inaturalist-observations-scraper) on the Apify Store and click **Try for free**.

#### Step 2 — Configure your input

Fill in the input fields in the Apify Console UI (or paste a JSON input directly):

- **Taxon Name**: Type any scientific or common name, e.g. `Monarch Butterfly` or `Danaus plexippus`. Leave blank for all species.
- **Iconic Taxon Group**: Select a major group like `Aves` (birds) or `Plantae` (plants). Leave blank for all.
- **Place ID**: Enter an integer place ID. For example, `1` = United States, `6` = California. Find IDs at https://www.inaturalist.org/places.
- **Quality Grade**: Enter `research` for verified observations only, or leave blank for all.
- **Date From / Date To**: Narrow to a specific date range in `YYYY-MM-DD` format.
- **Max Results**: How many records to retrieve (1–10,000). Default is 200.

#### Step 3 — Run the Actor

Click **Start** and wait for the run to complete. Typical runs finish in seconds to a few minutes depending on `maxResults`.

#### Step 4 — Download results

Go to the **Dataset** tab in the run detail and export as JSON, CSV, or Excel. You can also access results via the Apify API or Apify's integrations (Google Sheets, Zapier, Make, etc.).

### Input Example

```json
{
    "taxonName": "Danaus plexippus",
    "iconicTaxon": "Insecta",
    "qualityGrade": "research",
    "dateFrom": "2025-01-01",
    "dateTo": "2025-12-31",
    "maxResults": 500
}
````

Empty input `{}` works too — it returns the 200 most recent observations across all species.

### Output Example

```json
{
    "id": 375570786,
    "scientificName": "Sylvilagus audubonii",
    "commonName": "Desert Cottontail",
    "iconicTaxon": "Mammalia",
    "rank": "species",
    "observedOn": "2026-06-25",
    "placeGuess": "Los Angeles County, California, US",
    "latitude": 34.1454128827,
    "longitude": -118.0526442021,
    "qualityGrade": "needs_id",
    "observer": "example_user",
    "url": "https://www.inaturalist.org/observations/375570786",
    "photoUrl": "https://inaturalist-open-data.s3.amazonaws.com/photos/686586504/square.jpg"
}
```

### Pricing

This Actor uses **Pay Per Result** pricing — you only pay for records returned.

| Volume | Estimated cost |
|--------|---------------|
| 200 results (default) | ~$0.001 |
| 1,000 results | ~$0.003 |
| 10,000 results | ~$0.030 |

You also pay Apify's standard compute costs, which are minimal for this Actor (no browser required — pure API calls).

### Other Scrapers

Looking for more data? Check out these related Actors on the Apify Store:

- **CISA Known Exploited Vulnerabilities Scraper** — CVE threat intelligence feed
- **Hotfrog Business Scraper** — Local business directory data

### FAQ

**Q: Why are some latitude/longitude fields null?**
A: iNaturalist obscures exact GPS coordinates for threatened or endangered species to protect them from poaching. The `placeGuess` field still provides a location string.

**Q: Why does the Actor cap at 10,000 results?**
A: The iNaturalist API only allows paginating through the first 10,000 results of any given query. For larger datasets, narrow your query with taxon/place/date filters and run multiple Actor instances.

**Q: What is a "research grade" observation?**
A: An observation is research grade when it has at least 2 identifications that agree on the species-level ID with more than two-thirds agreeing. Research grade observations are the most reliable for scientific use.

**Q: Can I scrape observations for a specific national park or protected area?**
A: Yes. Look up the place ID for the park at https://www.inaturalist.org/places and enter it in the **Place ID** field.

**Q: How fresh is the data?**
A: The Actor queries the live iNaturalist API, so results are real-time. New observations appear within minutes of being submitted.

### Legal Disclaimer

This Actor retrieves publicly accessible data from the iNaturalist API in accordance with iNaturalist's [Terms of Service](https://www.inaturalist.org/pages/terms). iNaturalist data is made available under the [Creative Commons Attribution-NonCommercial](https://creativecommons.org/licenses/by-nc/4.0/) license for most observations. Users are responsible for complying with applicable data licensing terms and for ensuring their use of the data is lawful in their jurisdiction. This Actor is not affiliated with or endorsed by iNaturalist or the California Academy of Sciences.

For support, contact the Actor author via the Apify Store listing.

# Actor input Schema

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

Filter by species or taxon name (scientific or common). Examples: 'Danaus plexippus', 'Monarch Butterfly', 'Quercus robur'. Leave empty to get all recent observations.

## `iconicTaxon` (type: `string`):

Filter by major taxon group. Options: Aves (birds), Plantae (plants), Insecta (insects), Mammalia (mammals), Reptilia (reptiles), Amphibia (amphibians), Fungi, Arachnida, Mollusca, Actinopterygii (fish), Animalia. Leave empty for all groups.

## `placeId` (type: `integer`):

Filter by iNaturalist place ID (integer). For example, 1=US, 6=CA, 14=California, 97394=Yosemite NP. Find place IDs at https://www.inaturalist.org/places. Leave as 0 (or omit) for no place filter.

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

Filter by observation quality grade. Options: 'research' (verified), 'needs\_id' (unverified), 'casual'. Leave empty for all grades.

## `dateFrom` (type: `string`):

Only include observations on or after this date (YYYY-MM-DD format). Example: '2025-01-01'.

## `dateTo` (type: `string`):

Only include observations on or before this date (YYYY-MM-DD format). Example: '2025-12-31'.

## `maxResults` (type: `integer`):

Maximum number of observation records to return. iNaturalist API caps pagination at 10,000 results per query.

## Actor input object example

```json
{
  "taxonName": "",
  "iconicTaxon": "",
  "placeId": 0,
  "qualityGrade": "",
  "dateFrom": "",
  "dateTo": "",
  "maxResults": 200
}
```

# Actor output Schema

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/inaturalist-observations-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/inaturalist-observations-scraper").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 '{}' |
apify call compute-edge/inaturalist-observations-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iNaturalist Observations Scraper — Species & Biodiversity",
        "description": "Extract species observations from the iNaturalist API. Get scientific and common names, taxon group, date, location with coordinates, quality grade, observer, and photos. Filter by taxon, place, and quality grade. Clean JSON for biodiversity research.",
        "version": "0.1",
        "x-build-id": "TDsxk8ya6b8mOlwKq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~inaturalist-observations-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-inaturalist-observations-scraper",
                "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/compute-edge~inaturalist-observations-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-inaturalist-observations-scraper",
                "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/compute-edge~inaturalist-observations-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-inaturalist-observations-scraper",
                "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",
                "properties": {
                    "taxonName": {
                        "title": "Taxon Name",
                        "type": "string",
                        "description": "Filter by species or taxon name (scientific or common). Examples: 'Danaus plexippus', 'Monarch Butterfly', 'Quercus robur'. Leave empty to get all recent observations.",
                        "default": ""
                    },
                    "iconicTaxon": {
                        "title": "Iconic Taxon Group",
                        "type": "string",
                        "description": "Filter by major taxon group. Options: Aves (birds), Plantae (plants), Insecta (insects), Mammalia (mammals), Reptilia (reptiles), Amphibia (amphibians), Fungi, Arachnida, Mollusca, Actinopterygii (fish), Animalia. Leave empty for all groups.",
                        "default": ""
                    },
                    "placeId": {
                        "title": "Place ID",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter by iNaturalist place ID (integer). For example, 1=US, 6=CA, 14=California, 97394=Yosemite NP. Find place IDs at https://www.inaturalist.org/places. Leave as 0 (or omit) for no place filter.",
                        "default": 0
                    },
                    "qualityGrade": {
                        "title": "Quality Grade",
                        "type": "string",
                        "description": "Filter by observation quality grade. Options: 'research' (verified), 'needs_id' (unverified), 'casual'. Leave empty for all grades.",
                        "default": ""
                    },
                    "dateFrom": {
                        "title": "Date From",
                        "type": "string",
                        "description": "Only include observations on or after this date (YYYY-MM-DD format). Example: '2025-01-01'.",
                        "default": ""
                    },
                    "dateTo": {
                        "title": "Date To",
                        "type": "string",
                        "description": "Only include observations on or before this date (YYYY-MM-DD format). Example: '2025-12-31'.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of observation records to return. iNaturalist API caps pagination at 10,000 results per query.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
