# UniProt Enzyme Function Records - EC & Catalysis (`nexgensignal/uniprot-enzyme-function-records`) Actor

UniProtKB enzyme entries (ec:\*) as clean per-record data - EC number, catalytic activity, cofactors, pathway, gene, organism and review status. ~26.6M total, partition required. No author fields. CC BY 4.0, $0.05 per record.

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

## Pricing

from $33.50 / 1,000 enzyme function 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## UniProt Enzyme Function Records - EC & Catalysis

Every enzyme in UniProtKB - each UniProtKB entry that carries an **Enzyme Commission (EC) number** - as one
clean, flat record, with the **EC number and catalytic activity as the grain**, plus cofactors, pathway,
gene, organism and review status. Reproduced verbatim from the UniProt REST API, values unmodified, no
literature-author or contact field ever read.

### What one record represents

The source is **UniProt** (the UniProtKB REST API), filtered to `ec:*` - entries with at least one EC
number. Each record is **one enzyme entry**: its primary accession and entry name, the recommended protein
name, the **EC number(s)** (gathered from the protein-name annotation and from the catalytic-activity
reactions), the **catalytic activity** reaction description(s) verbatim, the cofactor(s), the pathway
comment, gene name(s), organism and NCBI taxonomy id, whether the entry is reviewed (Swiss-Prot) or
unreviewed (TrEMBL), and the protein-existence evidence level.

This is deliberately a different grain from the fleet's reviewed-protein and human-proteome cells: those
emit accession/protein/gene/organism/function/status and **no EC or catalytic-activity field**. This cell
leads with the enzymology - the EC classification and the reaction the enzyme catalyses.

### Sample output

![Sample output — UniProt Enzyme Function Records - EC & Catalysis](https://api.apify.com/v2/key-value-stores/IXCaMKjxSmUTLHhmq/records/uniprot-enzyme-function-records.png)

*Real rows from a live run of this actor (first 5 rows, selected columns).*

One full record from the same run, exactly as delivered:

```json
{
  "accession": "A0A1B0GTW7",
  "entry_name": "CIROP_HUMAN",
  "protein_name": "Ciliated left-right organizer metallopeptidase",
  "ec_numbers": "3.4.24.-",
  "catalytic_activity": null,
  "cofactors": "Zn(2+)",
  "pathway": null,
  "gene_names": "CIROP",
  "organism": "Homo sapiens",
  "organism_id": 9606,
  "reviewed": true,
  "protein_existence": "1: Evidence at protein level",
  "entry_type": "UniProtKB reviewed (Swiss-Prot)",
  "record_id": "A0A1B0GTW7",
  "source": "UniProt (UniProtKB)",
  "source_query": "ec:* AND <partition> (UniProtKB enzymes with an EC number)",
  "licence": "UniProt (UniProtKB), CC BY 4.0. Attribution required; reproduced from the UniProt REST API, values unmodified. No literature-author, submitter or contact field is read.",
  "attribution": "UniProt Consortium (https://www.uniprot.org)",
  "caveat": "UniProtKB entries carrying an Enzyme Commission (EC) number, with the EC number and catalytic activity as the grain (plus cofactors, pathway, organism and review status). The full ec:* set is about 26.6 million entries, so a partition (e.g. organism_id:9606, ec:3.*, taxonomy_id:2) is required and AND-ed onto ec:*. Distinct from the reviewed-protein and human-proteome cells: those emit no EC/catalytic-activity fields and are far smaller - about 279,671 of these enzyme records are also reviewed (Swiss-Prot) entries (~1.1%) and about 35,916 are human (~0.13%); the rest are unreviewed enzyme entries in neither cell.",
  "observed_at": "2026-09-25T17:27:12Z"
}
```

### Coverage and volume

The live `ec:*` set is **26,622,093 UniProtKB entries** (measured at build time from the API's
`x-total-results`). Because that is far too large for a single pull, a **partition is required**: you supply
a UniProt query fragment - `organism_id:9606` (human), `ec:3.*` (hydrolases), `taxonomy_id:2` (Bacteria),
`reviewed:true` (Swiss-Prot enzymes) and so on - and the Actor AND-s it onto `ec:*`. The full-set figure is
the capacity line; you always work within a partition.

**Sol's Wave-3 index put this door at about 24,964,845 records; measured live at build time the `ec:*` set
is 26,622,093 - the larger, current figure is what this listing quotes.**

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.

### Distinctness from the reviewed and human cells

Measured live against the door: **279,671** of these enzyme records are also reviewed (Swiss-Prot) entries -
about **1.1%** of the enzyme set - and **35,916** are human (organism 9606), about **0.13%**. The
overwhelming majority are unreviewed enzyme entries that appear in neither of the other cells. Because the
overlap is tiny and the emitted core (EC number, catalytic activity, cofactor, pathway) does not exist in
the other two cells, this Actor is a distinct product, not a re-filtering of an existing one. Stating the
overlap here means you can combine the cells without double-counting.

### 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, submitter or contact field is read.

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

### Person-data policy

This Actor requests **only** enzymology, protein, gene and organism fields. UniProt entries carry a
literature-references section with author and submitter 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.

### Interpretation caveat

UniProtKB entries carrying an Enzyme Commission (EC) number, with the EC number and catalytic activity as the grain (plus cofactors, pathway, organism and review status). The full ec:\* set is ~26.6M entries, so a partition (e.g. organism\_id:9606, ec:3.*) is required and AND-ed onto ec:*. Distinct from the reviewed-protein and human-proteome cells, which emit no EC/catalytic-activity fields.

Values are reproduced verbatim from the API; the Actor never rewrites a field. `catalytic_activity` is the
reaction description exactly as UniProt records it (it may cite ChEBI or Rhea identifiers); an entry that
carries an EC number but no annotated reaction leaves `catalytic_activity` null, which is faithful to the
source rather than invented.

### Data quality and freshness

`reviewed` is delivered as a real boolean; `organism_id` as a real number; EC numbers, catalytic activities
and cofactors are semicolon- or pipe-joined strings preserving every value. Delivery is keyed on the stable
accession, so the dataset is safe to diff, deduplicate or upsert. Every run re-reads the live API, so the
data is as fresh as UniProt publishes (on their release cycle), and each record's `observed_at` stamp dates
the snapshot. The run's `RUN_RECEIPT` records the partition, the API's total result count, and 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`, and the search path is confirmed crawlable
before any data request. The API is keyless. The Actor never bypasses a block or fetches through a mirror.

### Inputs

- **Partition** (`partition`, required) - a UniProt query fragment AND-ed onto `ec:*` to keep the slice
  tractable. Prefilled with `organism_id:9606`.
- **Maximum records** (`maxRecords`) - hard cap on enzyme records delivered and billed within the partition.

### 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, EC number(s), protein name, catalytic activity, organism, review
status and gene names.

### Fields in detail

The record leads with `accession` and `entry_name`, then `protein_name`, the enzymology core -
`ec_numbers`, `catalytic_activity`, `cofactors`, `pathway` - followed by `gene_names`, `organism`,
`organism_id`, the boolean `reviewed` (and the verbatim `entry_type`) and `protein_existence`. 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, and onto the fleet's other UniProt cells.

### Scaling and limits

Set **Maximum records** low to sample cheaply or high to pull a full partition. 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 large partition proceeds without gaps or duplicates. Choose the partition to match your question - a
single EC class, a single organism, or reviewed-only - and re-run to keep a downstream enzymology reference
current; each record's `observed_at` stamp dates the snapshot.

### Choosing a partition

The partition is the one required input, and it is what makes a 26-million-entry door tractable. Pick it to
match your question. `organism_id:9606` gives every human enzyme; `taxonomy_id:2` every bacterial enzyme;
`ec:3.*` every hydrolase across all organisms; `ec:1.1.1.*` a single enzyme sub-subclass; `reviewed:true`
the ~280,000 manually curated Swiss-Prot enzymes. You can combine fragments in the fragment itself
(`organism_id:9606 AND reviewed:true`) because it is passed to UniProt's own query parser. If a partition
still exceeds what you want to pull, the **Maximum records** cap bounds the run; you are billed only for
what is delivered. The `RUN_RECEIPT` records the partition and the live total for that partition, so you
always know what fraction of the slice you took.

### Typical uses

Drug-discovery and bioinformatics teams use this cell to assemble an enzyme reference for a target organism
or EC class - accession, EC number and the catalytic reaction in one flat table - without parsing UniProt's
nested JSON themselves. Because the EC number and reaction text are first-class fields, the dataset joins
directly onto pathway models, ChEBI/Rhea reaction references and gene panels. A scheduled run per partition
keeps a downstream enzymology table current with UniProt's release cycle, and the stable accession key makes
the dataset safe to upsert.

### Sibling Actors

It sits beside the fleet's UniProt reviewed-protein and human-proteome records, which draw the same door at a different grain. It shares its engineering - the runtime robots gate, cursor paging, push-then-charge
billing and verbatim-value discipline - with the fleet's other UniProt records Actors, from which it stays
distinct by leading with the EC number and the catalytic reaction rather than the protein summary.

# Actor input Schema

## `partition` (type: `string`):

Required. A UniProt query fragment AND-ed onto ec:\* to keep the slice tractable (the full enzyme set is ~26.6M). Examples: organism\_id:9606 (human), ec:3.\* (hydrolases), taxonomy\_id:2 (Bacteria), reviewed:true (Swiss-Prot enzymes).

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

Maximum enzyme records delivered and billed within the partition. You are billed only for records delivered.

## Actor input object example

```json
{
  "partition": "organism_id:9606",
  "maxRecords": 500
}
```

# Actor output Schema

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

The delivered UniProt enzyme function 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 = {
    "partition": "organism_id:9606",
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/uniprot-enzyme-function-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 = {
    "partition": "organism_id:9606",
    "maxRecords": 500,
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/uniprot-enzyme-function-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/LfermfkxQKmegmSc8/builds/byXmgL17n9mEi5fWo/openapi.json