# UniProt Reviewed Proteins — Swiss-Prot, Per Record (`nexgensignal/uniprot-reviewed-protein-records`) Actor

UniProt reviewed (Swiss-Prot) protein entries as clean per-record references - accession, protein/gene names, organism, function and review status, across all organisms. No author fields. CC BY 4.0, $0.05 per record.

- **URL**: https://apify.com/nexgensignal/uniprot-reviewed-protein-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 reviewed protein records

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/actors/running/actors-in-store.md#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

## UniProt Reviewed Proteins — Swiss-Prot, Per Record

Turn UniProt's reviewed (Swiss-Prot) protein set into clean, per-record target references - one row per manually curated protein entry with accession, protein and gene names, organism, function and status, ready for life-science data teams to enrich validated targets.

Each UniProtKB entry becomes **one clean, flat record** - accession, protein and gene names, organism,
review status, protein-existence evidence, sequence length, a function summary and keywords - with the
review status normalized to a real boolean, a stable `record_id` (the accession), and provenance stamped
on every row.

### What one record represents

The source is **UniProt** (the UniProtKB REST API). This cell runs the `reviewed:true` query - the manually curated Swiss-Prot entries across all organisms. Each record is **one protein
entry**: its primary accession and entry name, the recommended protein name, gene name(s), organism and
NCBI taxonomy id, whether the entry is reviewed (Swiss-Prot) or unreviewed (TrEMBL), the protein-existence
evidence level, the sequence length, a function summary, and the UniProt keywords.

### Coverage and volume

The reviewed (Swiss-Prot) set holds about **575,503** entries across all organisms - that is the record capacity of a full pull.

**Live count: 575,503 reviewed entries - matches the Wave-3 index figure exactly.**

About **20,431** of these reviewed entries are human (organism 9606) and therefore also appear in the sibling `uniprot-human-proteome-records` cell - that is 3.6% of this reviewed set. The two cells are distinct products (all reviewed organisms here; all human entries, mostly unreviewed, there) and the overlap is stated in both READMEs.

The Actor pages the UniProt REST API using its cursor (the `Link` header's `rel="next"`), 500 entries at
a time, and stops as soon as your **Maximum records** cap is met.

### Licence and attribution

UniProt data is released under **Creative Commons Attribution 4.0 (CC BY 4.0)** - free to use and
redistribute with attribution. The full notice travels on every record:

> UniProt (UniProtKB), CC BY 4.0. Attribution required; reproduced from the UniProt REST API, values unmodified. No literature-author or contact fields are read.

The required attribution - `UniProt Consortium (https://www.uniprot.org)` - is present on every record, and the UniProt licence
page is the governing reference.

### Interpretation caveat

Reviewed (Swiss-Prot) UniProtKB entries across all organisms - manually curated protein records. Only accession, protein/gene, organism and function/status fields are emitted.

Values are reproduced verbatim from the API; the Actor never rewrites a field. The `function` field is
the first UniProt function comment, which may cite PubMed identifiers - those are literature references,
not author names.

### Person-data policy

This Actor emits **only** protein, gene, organism and function/status fields. UniProt entries carry a
literature-references section with author names; that section is **never requested and never delivered**,
and a per-record assertion rejects any author, submitter or contact field (verified with a planted-field
test). No natural-person data is processed.

### Data quality and freshness

`reviewed` is delivered as a real boolean and `organism_id`/`sequence_length` as real numbers. Every run
re-reads the live API, so the data is as fresh as UniProt publishes (updated on their release cycle), and
each record's `observed_at` stamp dates the snapshot. Delivery is keyed on the stable accession, so the
dataset is safe to diff, deduplicate or upsert. The run's `RUN_RECEIPT` records the API's total result
count alongside how many records were delivered and charged.

### Provenance and compliance

Every run reads `rest.uniprot.org/robots.txt` at runtime; the gate result (URL, status, byte length,
SHA-256 of the policy) is written to the run's `RUN_RECEIPT`. The API is keyless. The Actor never
bypasses a block or fetches through a mirror.

### Inputs

- **Maximum records** (`maxRecords`) - hard cap on protein records delivered and billed.

### Output

Records land in the Actor's default dataset and export as JSON, CSV, Excel or via the Apify API. A
tabular **overview view** surfaces accession, entry name, protein and gene names, organism, review status,
protein existence, sequence length and keywords.

### Fields in detail

The record leads with `accession` and `entry_name`, then `protein_name`, `gene_names`, `organism` and
`organism_id`, the boolean `reviewed` (and the verbatim `entry_type`), `protein_existence`,
`sequence_length`, `function` and `keywords`. The provenance block closes every record. Because the
accession is UniProt's stable primary key, this dataset joins cleanly onto any system that references
UniProt accessions.

### Scaling and limits

Set **Maximum records** low to sample cheaply or high to pull the full set. The Actor pages the API with
its cursor (500 entries per request) and delivers incrementally, so memory stays flat regardless of how
many records you request, and you are billed only for what is delivered. The cursor is stable across a
run, so even a multi-hundred-thousand-entry pull proceeds without gaps or duplicates. Because UniProt
republishes on a fixed release cycle, re-running the Actor picks up new and updated entries automatically,
and each record's `observed_at` stamp dates the snapshot - schedule a run to keep a downstream reference
current. To build a cross-organism or cross-cut panel, run the relevant cells and join on the accession,
which is UniProt's stable primary key and never changes for an entry.

### The reviewed / human overlap

The two UniProt cells in this fleet intentionally overlap on the reviewed-human entries and are otherwise
distinct. The reviewed cell is every manually curated Swiss-Prot entry across all organisms; the human
cell is every human entry, the large majority of which are unreviewed (TrEMBL) and appear only there. If
you want only high-confidence human targets, take the intersection (reviewed and human); if you want the
complete human universe including computationally annotated entries, use the human cell whole. Stating the
overlap on both records means you can combine or subtract the two cells without double-counting.

### Sibling Actors

This Actor is the **reviewed (Swiss-Prot)** cut; its sibling **`uniprot-human-proteome-records`** is the **all-human** cut (reviewed and unreviewed). Both are distinct from the fleet's **`chembl-target-catalogue-master`** (drug-target bioactivity) and the fleet-1 **FDA Purple Book Biologics** (biologic drug products) - proteins, drug targets and biologic drugs are three different layers. It shares its engineering - the runtime robots gate, push-then-charge billing and
verbatim-value discipline - with the fleet's other public-data records Actors.

### Pricing

This Actor uses Apify's pay-per-event model: a flat **$0.05 per record** actually delivered to the
dataset, and nothing else — no monthly rental, no per-run base fee, no compute charge. Deliver 40
records and you pay $2.00; deliver 10,000 and you pay $500.00. Billing is wired *after* delivery — each
record is pushed first and only then does the per-record event fire — so a mid-run failure can only
ever under-charge you, never over-charge. Use **Maximum records** to cap spend precisely.

### Typical uses

Enrich a target list with curated protein and gene names, organism and function; filter validated targets by keyword or protein-existence evidence; build a cross-organism protein reference; or feed a bioinformatics, drug-discovery or annotation pipeline with clean reviewed-protein records.

### What this Actor does not do

It does not deliver literature-author, submitter or contact fields; it does not include the full sequence
or cross-reference dumps; and it does not alter any published value. It gives you a faithful, CC BY,
analysis-ready protein reference - one row per entry - with a provenance trail you can audit on every run.
Every value is UniProt's own, reproduced exactly, so the record is as authoritative as the source database.

# Actor input Schema

## `maxRecords` (type: `integer`):

Maximum reviewed protein records delivered and billed. The full reviewed (Swiss-Prot) set is about 575,503 entries.

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

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

The delivered UniProt reviewed protein record.

# 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/uniprot-reviewed-protein-records").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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/uniprot-reviewed-protein-records").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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/uniprot-reviewed-protein-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/uniprot-reviewed-protein-records"
        }
    }
}

```

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/SSquwJLeJ09t1ElTv/builds/Q5ahAXUoEHdiY2oVA/openapi.json