# InterPro Protein Families & Domains Scraper (`ninhothedev/interpro-scraper`) Actor

$0.5/1K 🔥 InterPro Domains! Fetch protein families, domains & functional signatures. No key. JSON, CSV, Excel or API in seconds. Annotate proteomes and functional predictions ⚡

- **URL**: https://apify.com/ninhothedev/interpro-scraper.md
- **Developed by:** [ninhothedev](https://apify.com/ninhothedev) (community)
- **Categories:** Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## InterPro Protein Families & Domains Scraper

Scrape **protein families, domains, functional sites, GO terms and member-database signatures** from [InterPro](https://www.ebi.ac.uk/interpro/) — the EBI resource that classifies proteins into families and predicts the presence of domains and important sites. **No API key. No login.** Just point it at a type, a search term, or a list of accessions.

InterPro integrates predictive signatures from member databases (Pfam, SMART, CDD, PROSITE, PRINTS, PANTHER and more) into a single classification of over **54,000 entries**. This actor turns that into clean, structured JSON ready for annotation pipelines, spreadsheets, or downstream analysis.

> Pricing: pay-as-you-go, roughly **~$0.5 per 1,000 entries** scraped (plus Apify platform usage). The InterPro REST API is free.

### What makes this different from my other biology actors

InterPro answers **"what family/domain is this protein and what does it do?"** — it is the *classification & functional annotation* layer. That is a different question from the other scrapers on this account:

| Actor | Answers | Layer |
|-------|---------|-------|
| **InterPro** (this one) | Which **families, domains & functional sites** does a protein contain? GO terms, member DBs | Classification / annotation |
| [UniProt scraper](https://apify.com/ninhothedev/uniprot-scraper) | What is the protein — its **sequence**, names, function text, features | Sequence / knowledgebase |
| [AlphaFold scraper](https://apify.com/ninhothedev/alphafold-structures-scraper) | What is its **3D structure** (predicted model, pLDDT, PDB/CIF) | Structure |
| [Reactome scraper](https://apify.com/ninhothedev/reactome-pathways-scraper) | Which **pathways** is it in | Pathways |
| [STRING scraper](https://apify.com/ninhothedev/string-interactions-scraper) | Which proteins does it **interact** with | Interaction networks |

In short: **UniProt gives you the sequence, AlphaFold gives you the structure, and InterPro tells you which families and domains that sequence belongs to.** Use them together.

### Modes

- **`entries`** — browse/filter all InterPro entries, optionally by type (`domain`, `family`, `site`, ...).
- **`search`** — free-text query (e.g. `"kinase"`, `"zinc finger"`).
- **`accessions`** — resolve an explicit list of InterPro accessions (e.g. `IPR000719`) to full detail records with GO terms, counters and descriptions.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | select | `entries` (default), `search`, or `accessions`. |
| `entryType` | select | `any` (default), `family`, `domain`, `repeat`, `site`, `conserved_site`, `binding_site`, `active_site`, `ptm`. Applies to `entries` and `search`. |
| `queries` | array | Search terms for `search` mode, e.g. `["kinase", "zinc finger"]`. |
| `accessions` | array | InterPro accession IDs for `accessions` mode, e.g. `["IPR000719"]`. |
| `maxItems` | integer | Max records to output (default 200, max 5000). |

#### Example input

```json
{
  "mode": "accessions",
  "accessions": ["IPR000719", "IPR011009"],
  "maxItems": 200
}
```

### Output

Each dataset item:

```json
{
  "type": "interpro_entry",
  "accession": "IPR000719",
  "name": "Protein kinase domain",
  "entry_type": "domain",
  "source_database": "interpro",
  "description": "This entry represents the protein kinase domain ...",
  "protein_count": 1949997,
  "structure_count": 8165,
  "taxa_count": 40328,
  "go_terms": [{"id": "GO:0005524", "name": "ATP binding", "category": "molecular_function"}],
  "go_term_count": 2,
  "member_databases": ["profile", "pfam", "smart"],
  "member_db_count": 3,
  "integrated": null,
  "literature_count": 10,
  "url": "https://www.ebi.ac.uk/interpro/entry/InterPro/IPR000719/",
  "source": "interpro",
  "scraped_at": "2026-08-11T00:00:00Z"
}
```

All fields are nullable. Counters (`protein_count`, `structure_count`, `taxa_count`) and GO terms are richest in `accessions` mode, which fetches the full entry detail.

### Use cases

- **Protein annotation** — attach family/domain and GO-term context to a list of accessions.
- **Functional genomics** — enrich gene/protein sets with functional-site classification.
- **Domain analysis** — pull every `domain`-type entry and its member-database signatures.
- **Bioinformatics pipelines** — a keyless, structured feed of InterPro classification for reproducible workflows.

### Notes

- Data © EMBL-EBI / InterPro, provided under their terms; this actor is an unofficial client of the public REST API.
- Pagination uses InterPro cursor URLs; large runs page automatically until `maxItems`.

# Actor input Schema

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

How to select InterPro entries. 'entries' browses/filters all InterPro entries (optionally by type); 'search' runs free-text queries; 'accessions' resolves an explicit list of InterPro accessions to full detail records.

## `entryType` (type: `string`):

Filter InterPro entries by type. Applies to 'entries' and 'search' modes. Use 'any' for no type filter.

## `queries` (type: `array`):

Free-text terms to search InterPro entries by (used in 'search' mode). Example: \["kinase", "zinc finger"].

## `accessions` (type: `array`):

Explicit InterPro accession IDs to fetch full detail for (used in 'accessions' mode). Example: \["IPR000719"].

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

Maximum number of InterPro entry records to output across the whole run.

## Actor input object example

```json
{
  "mode": "entries",
  "entryType": "any",
  "queries": [
    "kinase",
    "zinc finger"
  ],
  "accessions": [
    "IPR000719"
  ],
  "maxItems": 200
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "queries": [
        "kinase",
        "zinc finger"
    ],
    "accessions": [
        "IPR000719"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ninhothedev/interpro-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 = {
    "queries": [
        "kinase",
        "zinc finger",
    ],
    "accessions": ["IPR000719"],
}

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

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "kinase",
    "zinc finger"
  ],
  "accessions": [
    "IPR000719"
  ]
}' |
apify call ninhothedev/interpro-scraper --silent --output-dataset

```

## MCP server setup

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

```

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

## OpenAPI specification

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