# IUCN Red List Endangered Species Search (`ryanclinton/iucn-red-list-search`) Actor
Search the IUCN Red List of Threatened Species to retrieve conservation status, taxonomy, population trends, habitats, threats, and conservation actions for any of the 150,000+ species assessed by the International Union for Conservation of Nature.
- **URL**: https://apify.com/ryanclinton/iucn-red-list-search.md
- **Developed by:** [Ryan Clinton](https://apify.com/ryanclinton) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.00 / 1,000 species fetcheds
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
## IUCN Red List Search -- Endangered Species Data Extractor
Search the IUCN Red List of Threatened Species to retrieve conservation status, taxonomy, population trends, habitats, threats, and conservation actions for any of the 150,000+ species assessed by the International Union for Conservation of Nature.
Look up individual species by scientific name (e.g., "Panthera tigris" for the tiger or "Gorilla gorilla" for the gorilla), browse entire threat categories like Critically Endangered or Vulnerable, or search by taxonomic group (e.g., "Felidae" for all cat species). All data is retrieved through the official IUCN Red List API v4 and delivered as structured, export-ready output in JSON, CSV, or Excel format.
---
### Why use IUCN Red List Search?
The IUCN Red List is the world's most authoritative inventory of the global conservation status of biological species. Researchers, conservation organizations, environmental consultants, and policy makers rely on it daily. But accessing this data programmatically means dealing with API authentication, pagination, and joining multiple endpoints for taxon lookups, assessment details, habitat data, and threat classifications.
This actor handles all of that complexity for you. Provide a scientific name like "Panthera tigris" or "Loxodonta africana", select a threat category like Critically Endangered, or enter a family name like "Felidae" -- and the actor returns fully structured records with complete taxonomy, population trends, habitats, threats, and conservation actions. Every record is ready for analysis, reporting, or direct integration into your workflows.
Running on Apify gives you cloud-based execution with zero local setup, automatic dataset storage with built-in export to JSON/CSV/Excel, scheduling for recurring monitoring, and seamless integration with tools like Google Sheets, Zapier, Make, and Slack through webhooks and the Apify API. There is nothing to install and no infrastructure to maintain.
Whether you are tracking the conservation trajectory of a single species over time, compiling data for an environmental impact assessment, building a biodiversity dashboard, or enriching ecological datasets with authoritative IUCN classifications, this actor provides the structured data pipeline you need.
---
### Key features
- **Species search by scientific name** -- Look up any species using its Latin binomial name (e.g., "Panthera tigris", "Gorilla gorilla") and retrieve the latest conservation assessment along with historical assessments.
- **Browse by Red List category** -- Retrieve paginated lists of all Critically Endangered, Endangered, Vulnerable, or any other Red List category species without specifying individual names.
- **Taxonomic hierarchy search** -- Search by family (e.g., "Felidae"), order (e.g., "Carnivora"), class, or kingdom to get all assessed species within that taxonomic group.
- **Full assessment details** -- Each result includes habitat types, identified threats, recommended conservation actions, population trend direction, and the assessment publication year.
- **Complete taxonomy** -- Output includes all seven taxonomic ranks -- kingdom, phylum, class, order, family, genus -- plus the scientific name and English common name for every species record.
- **Historical assessment tracking** -- When searching by scientific name, retrieve multiple assessments to see how a species' conservation status has changed across assessment cycles over the years.
- **Eight threat categories supported** -- Search or filter by any of the eight IUCN categories: Extinct (EX), Extinct in the Wild (EW), Critically Endangered (CR), Endangered (EN), Vulnerable (VU), Near Threatened (NT), Least Concern (LC), and Data Deficient (DD).
- **Direct IUCN links** -- Every result includes a URL linking to the official IUCN Red List species page for verification and further reading.
- **Dry-run mode** -- Run without an API key to get step-by-step instructions on obtaining your free IUCN credentials before committing to a full search.
- **Configurable result limits** -- Control the number of species returned (1 to 200) to manage API usage and processing time.
---
### How to use
#### Using the Apify Console
1. Navigate to the [IUCN Red List Search actor page](https://apify.com/ryanclinton/iucn-red-list-search) on Apify.
2. Click **Start** to open the input configuration form.
3. Obtain your free IUCN API key by registering at [https://api.iucnredlist.org/](https://api.iucnredlist.org/). Enter it in the **IUCN API Key** field. If you do not have one yet, you can run the actor without a key to receive step-by-step registration instructions.
4. Enter a species scientific name in the **Species Name** field using the Latin binomial format -- for example, "Panthera tigris" for the tiger, "Gorilla gorilla" for the western gorilla, or "Ailuropoda melanoleuca" for the giant panda. You can also enter a taxonomic group name such as "Felidae" to retrieve all cat species or "Ursidae" for all bear species.
5. Optionally select a **Red List Category** from the dropdown to filter results by threat level. If no species name is provided, selecting a category browses all species classified under that status.
6. Adjust **Max Results** to control how many records to return (default 25, maximum 200).
7. Click **Start** and wait for the run to complete. Single species lookups finish in seconds; category browsing may take a few minutes.
8. View results in the **Dataset** tab and download as JSON, CSV, Excel, or XML.
#### Using the API
```bash
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~iucn-red-list-search/runs?token=YOUR_APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"query": "Panthera tigris",
"category": "",
"apiKey": "YOUR_IUCN_API_KEY",
"maxResults": 25
}'
````
***
### Input parameters
| Name | Type | Required | Default | Description |
|------|------|----------|---------|-------------|
| `query` | String | Yes | `"Panthera tigris"` | Species scientific name (e.g., "Gorilla gorilla"), family name (e.g., "Felidae"), order, class, or kingdom name to search for. Uses Latin binomial format for species-level lookups. |
| `category` | String | No | `""` (All) | IUCN Red List category code to filter by or browse. Options: `CR` (Critically Endangered), `EN` (Endangered), `VU` (Vulnerable), `NT` (Near Threatened), `LC` (Least Concern), `DD` (Data Deficient), `EW` (Extinct in the Wild), `EX` (Extinct). |
| `apiKey` | String | No | -- | Your IUCN Red List API key (Bearer token). Free at . Required for real data; without it the actor runs in dry-run mode. |
| `maxResults` | Integer | No | `25` | Maximum number of species records to return. Range: 1--200. For species-level searches, values above 1 include historical assessments. |
**Example input (JSON):**
```json
{
"query": "Panthera tigris",
"category": "EN",
"apiKey": "your-iucn-api-key-here",
"maxResults": 10
}
```
**Tips:**
- Use full binomial names like "Panthera tigris" rather than common names like "tiger" -- the IUCN API requires scientific nomenclature. If you are unsure of a species' scientific name, look it up at [iucnredlist.org](https://www.iucnredlist.org/) first.
- Combine a family name query (e.g., "Felidae") with a category filter (e.g., "CR") to find only the critically endangered species within that taxonomic family.
- When browsing large categories like Least Concern (which contains tens of thousands of species), start with a small `maxResults` value to verify output before scaling up.
- Set `maxResults` to a value greater than 1 when searching by species name to include historical assessments alongside the latest one, giving you a timeline of conservation status changes.
***
### Output
Each species record in the output dataset contains the following structured fields:
```json
{
"taxonId": 15955,
"scientificName": "Panthera tigris",
"commonName": "Tiger",
"kingdom": "ANIMALIA",
"phylum": "CHORDATA",
"className": "MAMMALIA",
"order": "CARNIVORA",
"family": "FELIDAE",
"genus": "Panthera",
"category": "EN - Endangered",
"populationTrend": "Increasing",
"habitat": "Forest - Subtropical/Tropical Moist Lowland; Forest - Subtropical/Tropical Dry; Forest - Subtropical/Tropical Moist Montane; Forest - Temperate; Grassland - Subtropical/Tropical Dry; Wetlands (inland) - Shrub Dominated Wetlands",
"threats": "Residential & commercial development - Housing & urban areas; Agriculture & aquaculture - Annual & perennial non-timber crops; Biological resource use - Hunting & trapping terrestrial animals; Transportation & service corridors - Roads & railroads; Human intrusions & disturbance - War, civil unrest & military exercises",
"conservationActions": "Land/water protection - Site/area protection; Land/water management - Site/area management; Species management - Harvest management; Law & policy - Legislation; Law & policy - Policies and regulations",
"assessmentDate": 2022,
"iucnUrl": "https://www.iucnredlist.org/species/15955",
"extractedAt": "2026-02-19T10:30:00.000Z"
}
```
| Field | Type | Description |
|-------|------|-------------|
| `taxonId` | Number | IUCN Species Information Service (SIS) unique identifier for the taxon. |
| `scientificName` | String | Full Latin binomial name of the species (e.g., "Panthera tigris"). |
| `commonName` | String | English common name, preferring the designated main name when available. |
| `kingdom` | String | Taxonomic kingdom (e.g., "ANIMALIA", "PLANTAE"). |
| `phylum` | String | Taxonomic phylum (e.g., "CHORDATA"). |
| `className` | String | Taxonomic class (e.g., "MAMMALIA", "AVES"). |
| `order` | String | Taxonomic order (e.g., "CARNIVORA", "PRIMATES"). |
| `family` | String | Taxonomic family (e.g., "FELIDAE", "HOMINIDAE"). |
| `genus` | String | Taxonomic genus (e.g., "Panthera", "Gorilla"). |
| `category` | String | IUCN Red List category code and label (e.g., "EN - Endangered", "CR - Critically Endangered"). |
| `populationTrend` | String | Direction of population change: "Increasing", "Decreasing", "Stable", or "Unknown". |
| `habitat` | String | Semicolon-separated list of habitat types where the species is found. |
| `threats` | String | Semicolon-separated list of identified threats to the species. |
| `conservationActions` | String | Semicolon-separated list of recommended or active conservation measures. |
| `assessmentDate` | Number | Year the IUCN assessment was published. |
| `iucnUrl` | String | Direct URL to the species page on the IUCN Red List website. |
| `extractedAt` | String | ISO 8601 timestamp of when the data was extracted by this actor. |
***
### Use cases
- **Environmental impact assessments** -- Compile lists of threatened species in a project area by searching taxonomic groups and filtering by threat category to satisfy regulatory requirements.
- **Conservation research** -- Track how a species' Red List status has changed over time by retrieving historical assessments for species like Gorilla gorilla or Panthera tigris.
- **Biodiversity dashboards** -- Feed structured species data into visualization tools to build interactive dashboards showing threat distributions, population trends, and habitat breakdowns.
- **Grant proposal preparation** -- Gather up-to-date conservation status data for target species to strengthen funding applications with authoritative IUCN references.
- **Wildlife trade compliance** -- Cross-reference species against IUCN threat categories to support due diligence for CITES and wildlife trade regulations.
- **Educational content creation** -- Build lesson plans, infographics, and species profiles using structured taxonomy, threat, and conservation data from the IUCN Red List.
- **Species monitoring pipelines** -- Schedule recurring runs to detect when a species' conservation status changes, triggering alerts via webhooks to conservation teams.
- **Ecological data aggregation** -- Combine IUCN Red List data with occurrence records from GBIF, research papers from OpenAlex, or habitat maps to build comprehensive species profiles.
- **Policy analysis** -- Browse entire threat categories (e.g., all Critically Endangered species) to quantify the scope of conservation challenges for policy reports and white papers.
- **Journalism and reporting** -- Source authoritative species data for environmental journalism, fact-checking extinction claims, or creating data-driven conservation stories with proper IUCN citations.
- **NGO program design** -- Conservation nonprofits can compile lists of threatened species by region, family, or threat level to inform program priorities and donor communications.
***
### API & integration
#### Python
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run_input = {
"query": "Gorilla gorilla",
"category": "",
"apiKey": "YOUR_IUCN_API_KEY",
"maxResults": 5,
}
run = client.actor("ryanclinton/iucn-red-list-search").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(f"{item['scientificName']} -- {item['category']} ({item['populationTrend']})")
```
#### JavaScript
```javascript
import { ApifyClient } from "apify-client";
const client = new ApifyClient({ token: "YOUR_APIFY_TOKEN" });
const run = await client.actor("ryanclinton/iucn-red-list-search").call({
query: "Gorilla gorilla",
category: "",
apiKey: "YOUR_IUCN_API_KEY",
maxResults: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
console.log(`${item.scientificName} -- ${item.category} (${item.populationTrend})`);
});
```
#### cURL
```bash
## Start the actor run
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~iucn-red-list-search/runs?token=YOUR_APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"query": "Gorilla gorilla",
"apiKey": "YOUR_IUCN_API_KEY",
"maxResults": 5
}'
## Fetch results from the dataset (replace DATASET_ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN&format=json"
```
This actor integrates seamlessly with popular automation platforms and data tools:
- **Google Sheets** -- Export species data directly to a spreadsheet for collaborative analysis and charting.
- **Zapier / Make (Integromat)** -- Trigger downstream workflows when new species data is available.
- **Slack / Email** -- Receive notifications when a scheduled run completes via Apify webhooks.
- **Custom HTTP endpoints** -- Send results to any webhook URL for ingestion into your own systems.
Export results as JSON, CSV, XML, RSS, or Excel directly from the Apify dataset.
***
### How it works
1. **Input validation** -- The actor reads your search parameters (query, category, apiKey, maxResults) and checks for a valid API key. If no key is provided, it returns a dry-run response with step-by-step registration instructions and exits early without making any IUCN API calls.
2. **Search mode selection** -- The actor determines which IUCN API endpoint to use. If a species name is provided in the query field, it uses the scientific name search path. If only a category is selected with no query, it uses the category browse endpoint with automatic pagination.
3. **Taxonomic name resolution** -- For full binomial names (e.g., "Panthera tigris"), the actor calls `/taxa/scientific_name` with separate genus and species parameters. For single-word queries like "Felidae", it tries progressively broader taxonomic levels -- first family, then order, then class, then kingdom -- until it finds matching species.
4. **Category browsing with pagination** -- When browsing by Red List category, the actor paginates through the `/red_list_categories/{code}` endpoint, fetching pages of assessments until the requested maxResults count is reached or no more results are available.
5. **Assessment enrichment** -- For each species found, the actor makes an additional API call to `/assessment/{id}` to fetch the full assessment record. This enrichment step extracts habitat types, identified threats, recommended conservation actions, population trend direction, and the assessment publication year.
6. **Historical assessment retrieval** -- When searching by scientific name with `maxResults` greater than 1, the actor also retrieves older assessments sorted by year in descending order, showing how the species' conservation status has evolved across assessment cycles.
7. **Record assembly** -- Taxon data (taxonomy, common names) and assessment details (category, habitats, threats, actions) are merged into a flat, structured output record with 17 fields. English common names are prioritized, with the designated "main" name preferred when available.
8. **Output storage** -- All assembled records are pushed to the Apify dataset, immediately available for download in JSON, CSV, Excel, or XML format, and accessible via the Apify API for programmatic consumption.
```
+------------------+
| Input Params |
| query, category, |
| apiKey, maxRes |
+--------+---------+
|
v
+------------------+ +---------------------+
| No API key? | --> | Dry-run mode: |
| Return setup | | Registration steps |
| instructions | | returned to dataset |
+--------+---------+ +---------------------+
|
v
+------------------+ +---------------------+
| Search mode: | --> | IUCN API v4 Call |
| Name: /taxa/... | | Bearer auth token |
| Cat: /red_list.. | | Paginated fetch |
+------------------+ +----------+----------+
|
v
+------------------+ +---------------------+
| Apify Dataset | <-- | Enrich each taxon |
| JSON/CSV/Excel | | /assessment/{id} |
| API / Webhook | | Habitats, threats, |
| Scheduling | | actions, pop trend |
+------------------+ +---------------------+
```
***
### Performance & cost
| Metric | Details |
|--------|---------|
| **Memory usage** | 256 MB (minimum Apify allocation) -- the actor is lightweight since it calls an external API rather than parsing web pages |
| **Single species lookup** | Completes in 5--15 seconds, typically under $0.01 in Apify platform credits |
| **Family-level search (25 results)** | Completes in 30--90 seconds depending on family size and IUCN API response times |
| **Category browse (25 results)** | Completes in 30--90 seconds with sequential enrichment calls per species |
| **Category browse (200 results)** | Completes in 3--10 minutes, typically under $0.05 in Apify platform credits |
| **IUCN API key cost** | Free -- register at with no usage fees |
| **Rate limiting** | The actor makes sequential API calls to respect IUCN rate limits; typical usage patterns are well within allowed thresholds |
***
### Limitations
- **Scientific names only** -- The IUCN API does not support common name searches. You must use Latin binomial names (e.g., "Panthera tigris") or taxonomic group names (e.g., "Felidae"). Look up scientific names at [iucnredlist.org](https://www.iucnredlist.org/) if needed.
- **API key required** -- A free IUCN Red List API key is required for real data. Without one, the actor runs in dry-run mode with setup instructions only.
- **Maximum 200 results per run** -- The actor caps output at 200 species records per execution. For larger datasets, run the actor multiple times with different parameters.
- **Sequential API calls** -- Each species requires multiple API calls (taxon lookup + assessment details), so browsing large categories takes longer than single species lookups.
- **Assessment data availability** -- Some species have limited assessment data. Fields like habitat, threats, and conservation actions may be empty if the IUCN assessment does not include them.
- **English common names** -- The actor prefers English common names. Species without English names in the IUCN database will have an empty `commonName` field.
- **API availability** -- Results depend on the IUCN Red List API being accessible. Occasional API downtime or maintenance may cause temporary failures.
- **No subspecies-level search** -- The actor resolves species at the binomial level (genus + species). Subspecies and infrarank queries are not directly supported, though some may appear in results when available in the IUCN database.
***
### Responsible use
- **Respect IUCN terms of service** -- The IUCN Red List API is provided for non-commercial and research purposes. Review the [IUCN Red List terms](https://www.iucnredlist.org/terms/terms-of-use) before using this data in commercial applications.
- **Attribute the data source** -- When publishing or sharing results, credit the IUCN Red List as required by their citation guidelines: "IUCN 2024. The IUCN Red List of Threatened Species."
- **Use reasonable request volumes** -- Avoid scheduling high-frequency runs with large result sets. The IUCN API is a shared resource for the global conservation community.
- **Do not use for poaching or illegal trade** -- Species location and status data must never be used to facilitate wildlife trafficking, poaching, or any activity that harms endangered species.
- **Verify critical decisions** -- For regulatory compliance, environmental permits, or conservation planning, always cross-reference actor output with the official IUCN Red List website at [iucnredlist.org](https://www.iucnredlist.org/).
- **Keep your API key secure** -- Store your IUCN API key using the actor's secret input field. Do not share it publicly or embed it in client-side code.
***
### FAQ
**Q: How do I get a free IUCN API key?**
**A:** Visit , click "Sign Up" to create a free account, verify your email address, and then generate an API token from your profile page. The key is provided as a Bearer token.
**Q: Can I search by common name like "tiger" or "panda"?**
**A:** No. The IUCN Red List API requires scientific names. Search for "Panthera tigris" instead of "tiger", or "Ailuropoda melanoleuca" instead of "giant panda". You can look up the scientific name on [iucnredlist.org](https://www.iucnredlist.org/) first.
**Q: What do the Red List category codes mean?**
**A:** From highest to lowest extinction risk: EX (Extinct), EW (Extinct in the Wild), CR (Critically Endangered), EN (Endangered), VU (Vulnerable), NT (Near Threatened), LC (Least Concern), and DD (Data Deficient -- insufficient information to assess the species).
**Q: How do I search for all species in a taxonomic family?**
**A:** Enter the family name (e.g., "Felidae" for cats, "Ursidae" for bears, "Accipitridae" for hawks and eagles) in the Species Name field. The actor will search the IUCN API at the family taxonomic level and return all assessed species within that group.
**Q: Can I get historical assessment data for a species?**
**A:** Yes. When searching by scientific name, set `maxResults` to a value greater than 1. The actor returns the latest assessment first, followed by older assessments sorted by year in descending order. This lets you track how a species' status changed over time.
**Q: How often is the IUCN Red List updated?**
**A:** The IUCN Red List is updated multiple times per year, typically two to four major updates annually. The `assessmentDate` field in the output tells you when each species was last assessed.
**Q: What happens if I run the actor without an API key?**
**A:** The actor enters dry-run mode and returns a single record with instructions on how to register for a free IUCN API key. No species data is retrieved, and no API calls are made to the IUCN servers.
**Q: Can I combine a species query with a category filter?**
**A:** Yes. When you search by a taxonomic group name (e.g., family "Felidae") and also select a category (e.g., "CR"), the actor filters results to show only the critically endangered species within that family.
**Q: Why are some output fields empty?**
**A:** Not all IUCN assessments include every data point. Fields like `habitat`, `threats`, `conservationActions`, and `populationTrend` depend on the depth of the assessment. Data Deficient (DD) species in particular often have sparse records.
**Q: Can I schedule this actor to run automatically?**
**A:** Yes. Use Apify's scheduling feature to run the actor on a recurring basis -- daily, weekly, or monthly -- to monitor species status changes. Combine with webhooks to receive Slack, email, or HTTP notifications when new data is available.
**Q: Does this actor work with plant species too?**
**A:** Yes. The IUCN Red List covers animals, plants, and fungi. Search for any assessed species using its scientific name, or browse categories that include all kingdoms. For example, search "Araucaria araucana" for the Monkey Puzzle tree or browse "CR" to see critically endangered species across all taxonomic groups.
**Q: What is the difference between searching by name and browsing by category?**
**A:** Searching by name looks up a specific species (e.g., "Panthera tigris") or all species within a taxonomic group (e.g., family "Felidae"). Browsing by category retrieves a paginated list of all species classified under a particular threat level (e.g., all Critically Endangered species across all taxonomic groups worldwide). You can combine both approaches -- search a family name while filtering by category to narrow results.
***
### Related actors
| Actor | Description | Link |
|-------|-------------|------|
| GBIF Biodiversity Search | Search the Global Biodiversity Information Facility for species occurrence records, distribution data, and observation counts worldwide. | [ryanclinton/gbif-species-search](https://apify.com/ryanclinton/gbif-species-search) |
| OpenAlex Research Search | Find published research papers and academic publications about specific species, conservation biology, or ecology topics. | [ryanclinton/openalex-research-search](https://apify.com/ryanclinton/openalex-research-search) |
| Wikipedia Article Search | Look up Wikipedia articles about species for additional context, descriptions, and general reference information. | [ryanclinton/wikipedia-article-search](https://apify.com/ryanclinton/wikipedia-article-search) |
| WHO Global Health Observatory | Search global health data from the World Health Organization -- useful for zoonotic disease research linked to wildlife species. | [ryanclinton/who-gho-search](https://apify.com/ryanclinton/who-gho-search) |
| World Bank Development Indicators | Access development indicators including environmental and biodiversity metrics for country-level conservation context. | [ryanclinton/world-bank-indicators](https://apify.com/ryanclinton/world-bank-indicators) |
| Crossref Academic Paper Search | Search the Crossref database for peer-reviewed papers on conservation biology, species ecology, or any research topic. | [ryanclinton/crossref-paper-search](https://apify.com/ryanclinton/crossref-paper-search) |
# Actor input Schema
## `query` (type: `string`):
Species scientific name to search for (e.g. 'Panthera tigris' for tiger, 'Gorilla gorilla' for gorilla). Use 'Genus species' format.
## `category` (type: `string`):
Filter by IUCN Red List category. If set (and no query), browses all species in that category.
## `apiKey` (type: `string`):
Your IUCN Red List API key (free at https://api.iucnredlist.org/). Required for real data.
## `maxResults` (type: `integer`):
Maximum number of species to return
## Actor input object example
```json
{
"query": "Panthera tigris",
"category": "",
"maxResults": 25
}
```
# Actor output Schema
## `results` (type: `string`):
No description
# API
You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.
## JavaScript example
```javascript
import { ApifyClient } from 'apify-client';
// Initialize the ApifyClient with your Apify API token
// Replace the '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"query": "Panthera tigris"
};
// Run the Actor and wait for it to finish
const run = await client.actor("ryanclinton/iucn-red-list-search").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "query": "Panthera tigris" }
# Run the Actor and wait for it to finish
run = client.actor("ryanclinton/iucn-red-list-search").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 '{
"query": "Panthera tigris"
}' |
apify call ryanclinton/iucn-red-list-search --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=ryanclinton/iucn-red-list-search",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "IUCN Red List Endangered Species Search",
"description": "Search the IUCN Red List of Threatened Species to retrieve conservation status, taxonomy, population trends, habitats, threats, and conservation actions for any of the 150,000+ species assessed by the International Union for Conservation of Nature.",
"version": "1.0",
"x-build-id": "HCx7dKOHNf9cc2QsY"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/ryanclinton~iucn-red-list-search/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-ryanclinton-iucn-red-list-search",
"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/ryanclinton~iucn-red-list-search/runs": {
"post": {
"operationId": "runs-sync-ryanclinton-iucn-red-list-search",
"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/ryanclinton~iucn-red-list-search/run-sync": {
"post": {
"operationId": "run-sync-ryanclinton-iucn-red-list-search",
"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": [
"query"
],
"properties": {
"query": {
"title": "Species Name",
"type": "string",
"description": "Species scientific name to search for (e.g. 'Panthera tigris' for tiger, 'Gorilla gorilla' for gorilla). Use 'Genus species' format."
},
"category": {
"title": "Red List Category",
"enum": [
"",
"CR",
"EN",
"VU",
"NT",
"LC",
"DD",
"EW",
"EX"
],
"type": "string",
"description": "Filter by IUCN Red List category. If set (and no query), browses all species in that category.",
"default": ""
},
"apiKey": {
"title": "IUCN API Key",
"type": "string",
"description": "Your IUCN Red List API key (free at https://api.iucnredlist.org/). Required for real data."
},
"maxResults": {
"title": "Max Results",
"minimum": 1,
"maximum": 200,
"type": "integer",
"description": "Maximum number of species to return",
"default": 25
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```