# iNaturalist Scraper (`parseforge/inaturalist-scraper`) Actor

Scrape wildlife observations from iNaturalist. Get species identifications, photos, GPS coordinates, observer info, and quality grades for millions of sightings worldwide. Filter by taxon name, location, date range, quality grade, and photo availability. Ideal for biodiversity research.

- **URL**: https://apify.com/parseforge/inaturalist-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Education, Other
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.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.
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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🦋 iNaturalist Scraper

Whether you're a wildlife researcher tracking species sightings, a conservation organization monitoring biodiversity, or an educator building nature databases, this tool makes it easy to collect structured observation data from the world's largest citizen science platform.

> **The iNaturalist Scraper collects wildlife observations with species names, locations, coordinates, photos, observers, quality grades, and identification data. Filter by taxon, place, date range, quality grade, and more.**

### ✨ What Does It Do

- 🐾 **Species observations** - collect scientific names, common names, and taxonomic ranks for observed organisms
- 📍 **Location data** - extract GPS coordinates, place names, and geographic information for each sighting
- 📸 **Photo URLs** - get medium-resolution photo URLs for every observation
- 🏅 **Quality grades** - filter by research grade, needs ID, or casual observations
- 📅 **Date filtering** - search by date range to track seasonal patterns or recent sightings
- 🔬 **Identification data** - see agreement and disagreement counts for community identifications

### 🔧 Input

- **Taxon Name** - search for a specific species or group (e.g., 'whale', 'butterfly', 'eagle')
- **Max Items** - how many observations to collect (free users get 10 items, paid users up to 1,000,000)
- **Quality Grade** - filter by Research Grade, Needs ID, or Casual
- **Place ID** - filter by iNaturalist place ID (e.g., 1 for United States, 6 for Australia)
- **Start Date** - filter observations from this date (format: YYYY-MM-DD)
- **End Date** - filter observations up to this date (format: YYYY-MM-DD)
- **Has Photos** - only return observations that include photos
- **Order By** - sort by creation date, observation date, or votes

```json
{
    "taxonName": "whale",
    "maxItems": 50,
    "qualityGrade": "research",
    "placeId": 1,
    "hasPhotos": true
}
````

### 📊 Output

Each observation record includes up to 17+ data fields. Download as JSON, CSV, or Excel.

| Field | Description |
|-------|-------------|
| 🔗 uri | Observation page on iNaturalist |
| 🐾 speciesGuess | Observer's species guess |
| 🔬 taxonName | Scientific name |
| 🏷️ taxonCommonName | Common name |
| 📊 taxonRank | Taxonomic rank (species, genus, etc.) |
| 📅 observedOn | Date of observation |
| 📍 latitude | GPS latitude |
| 📍 longitude | GPS longitude |
| 🌍 placeGuess | Place description |
| 🏅 qualityGrade | Quality grade (research, needs\_id, casual) |
| ✅ numIdentificationAgreements | Community ID agreements |
| 📸 photoUrls | Observation photos |
| 👤 userName | Observer's name |

```json
{
    "id": 12345678,
    "speciesGuess": "Humpback Whale",
    "taxonName": "Megaptera novaeangliae",
    "taxonCommonName": "Humpback Whale",
    "taxonRank": "species",
    "observedOn": "2026-03-15",
    "createdAt": "2026-03-16T10:30:00+00:00",
    "latitude": 21.2743,
    "longitude": -157.8234,
    "placeGuess": "Maui, HI, US",
    "qualityGrade": "research",
    "numIdentificationAgreements": 3,
    "numIdentificationDisagreements": 0,
    "photoUrls": ["https://inaturalist-open-data.s3.amazonaws.com/photos/..."],
    "userName": "nature_observer",
    "userLogin": "nature_observer",
    "uri": "https://www.inaturalist.org/observations/12345678",
    "scrapedAt": "2026-04-09T12:00:00.000Z"
}
```

### 💎 Why Choose the iNaturalist Scraper?

| Feature | Our Tool | Manual iNaturalist Browsing |
|---------|----------|-----------------------------|
| Batch collection | ✅ Up to 1M observations | ❌ Browse one at a time |
| GPS coordinates | ✅ Lat/lng included | ⚠️ Map only |
| Date range filtering | ✅ Custom start/end dates | ⚠️ Limited filtering |
| Structured output | ✅ JSON, CSV, Excel | ❌ Web pages only |
| Automated scheduling | ✅ Daily/weekly monitoring | ❌ Manual visits |
| Photo URLs | ✅ Direct download links | ⚠️ Click each observation |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - set your taxon, location, date range, and how many observations you want
3. **Run It** - click "Start" and get structured wildlife data in seconds

No coding, no setup, no manual browsing required.

### 🎯 Business Use Cases

- 🔬 **Researchers** - collect species observation data with GPS coordinates for ecological studies
- 🌿 **Conservation orgs** - monitor endangered species sightings across regions and time periods
- 🎓 **Educators** - build biodiversity databases for classrooms and field studies
- 📊 **Data analysts** - study species distribution patterns, seasonal migration, and population trends
- 🗺️ **GIS professionals** - map wildlife observations with precise latitude and longitude data
- 📱 **App developers** - build nature identification or wildlife tracking apps with real observation data

### ❓ FAQ

🦋 **What is iNaturalist?**
iNaturalist is a citizen science platform with over 100 million observations from millions of contributors worldwide. It covers all living organisms, from insects to whales.

🏅 **What do the quality grades mean?**
"Research Grade" means the community has agreed on the species identification. "Needs ID" means more identifications are needed. "Casual" covers observations that may lack photos or location data.

📍 **What Place IDs can I use?**
Common Place IDs include: 1 (United States), 6712 (Canada), 6 (Australia), 7161 (United Kingdom). You can find Place IDs on the iNaturalist website.

📅 **Can I filter by date range?**
Yes. Use the Start Date and End Date fields in YYYY-MM-DD format to narrow observations to a specific time window.

📸 **Are photos included?**
Yes. When observations have photos, the scraper returns medium-resolution photo URLs that you can download directly.

### 🔗 Integrate iNaturalist Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate wildlife data workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts for new species sightings
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified in your team channel
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export observation data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more data collection tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| Hugging Face Model Scraper | Collect AI model data from Hugging Face | [Link](https://apify.com/parseforge/hugging-face-model-scraper) |
| Smart Apify Actor Scraper | Scrape actor data with 70+ fields | [Link](https://apify.com/parseforge/smart-apify-actor-scraper) |
| Greatschools Scraper | Collect school ratings and data | [Link](https://apify.com/parseforge/greatschools-scraper) |
| PR Newswire Scraper | Collect press releases and news | [Link](https://apify.com/parseforge/pr-newswire-scraper) |
| HTML to JSON Smart Parser | Parse any web page into structured data | [Link](https://apify.com/parseforge/html-to-json-smart-parser) |

**Pro Tip:** Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to iNaturalist, the California Academy of Sciences, or the National Geographic Society. It accesses only publicly available data.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Filter observations by taxon name (e.g., whale, butterfly, eagle).

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

Filter by observation quality grade.

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

Filter by iNaturalist place ID (e.g. 1 for United States, 6 for Australia).

## `startDate` (type: `string`):

Filter observations from this date (format: YYYY-MM-DD).

## `endDate` (type: `string`):

Filter observations up to this date (format: YYYY-MM-DD).

## `hasPhotos` (type: `boolean`):

Only return observations that have photos.

## `orderBy` (type: `string`):

Sort results by this field.

## Actor input object example

```json
{
  "maxItems": 10,
  "taxonName": "whale",
  "qualityGrade": "research",
  "hasPhotos": false,
  "orderBy": "created_at"
}
```

# Actor output Schema

## `overview` (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,
    "taxonName": "whale",
    "qualityGrade": "research"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/inaturalist-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,
    "taxonName": "whale",
    "qualityGrade": "research",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/inaturalist-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 '{
  "maxItems": 10,
  "taxonName": "whale",
  "qualityGrade": "research"
}' |
apify call parseforge/inaturalist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iNaturalist Scraper",
        "description": "Scrape wildlife observations from iNaturalist. Get species identifications, photos, GPS coordinates, observer info, and quality grades for millions of sightings worldwide. Filter by taxon name, location, date range, quality grade, and photo availability. Ideal for biodiversity research.",
        "version": "0.0",
        "x-build-id": "eGNaGIuVonWgQEPEv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~inaturalist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-inaturalist-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/parseforge~inaturalist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-inaturalist-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/parseforge~inaturalist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-inaturalist-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "taxonName": {
                        "title": "Taxon Name",
                        "type": "string",
                        "description": "Filter observations by taxon name (e.g., whale, butterfly, eagle)."
                    },
                    "qualityGrade": {
                        "title": "Quality Grade",
                        "enum": [
                            "research",
                            "needs_id",
                            "casual"
                        ],
                        "type": "string",
                        "description": "Filter by observation quality grade.",
                        "default": "research"
                    },
                    "placeId": {
                        "title": "Place ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Filter by iNaturalist place ID (e.g. 1 for United States, 6 for Australia)."
                    },
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Filter observations from this date (format: YYYY-MM-DD)."
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "Filter observations up to this date (format: YYYY-MM-DD)."
                    },
                    "hasPhotos": {
                        "title": "Has Photos",
                        "type": "boolean",
                        "description": "Only return observations that have photos.",
                        "default": false
                    },
                    "orderBy": {
                        "title": "Order By",
                        "enum": [
                            "created_at",
                            "observed_on",
                            "votes"
                        ],
                        "type": "string",
                        "description": "Sort results by this field.",
                        "default": "created_at"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```