# Molecular Evidence Pack Builder (`flintglade/molecular-evidence-pack-builder`) Actor

Build a bounded, verified molecular evidence dossier from declared public identifiers.

- **URL**: https://apify.com/flintglade/molecular-evidence-pack-builder.md
- **Developed by:** [Flintglade](https://apify.com/flintglade) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1,000.00 / 1,000 verified molecular dossiers

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Molecular Evidence Pack Builder

Build one bounded, cross-source molecular evidence dossier for an explicitly declared protein or enzyme family, with source-level provenance and a tamper-detecting portable ZIP.

### What this does not do

- No de novo drug discovery.
- No medicinal chemistry recommendation.
- No clinical inference.
- No unrestricted all-database query.
- No nested calls to paid Actors.
- No inclusion of incomparable bioactivity as if pooled.
- No public listing before one-family scientific validation and operator approval.

### Sources and authorization

Version 0.1 accepts only public identifiers and makes typed, bounded `GET` requests to official UniProt, PubChem, RCSB PDB, AlphaFold DB, and ChEMBL endpoints listed in [SOURCE_POLICY.md](SOURCE_POLICY.md). It does not accept arbitrary URLs, credentials, private datasets, or source tokens. It does not fall back to scraping, search engines, paid child Actors, or a broader source when an API fails.

Each fact carries an official request URL with query values redacted, a JSON evidence path, the raw-response SHA-256, and a versioned source contract. Source values are preserved alongside normalized values. New provider fields are listed as unmapped instead of being silently dropped.

### Input

Declare one family with 1–25 exact UniProt accessions and explicit inclusion/exclusion rules. Supply 0–500 exact PubChem CIDs, ChEMBL molecule IDs, InChIKeys, or SMILES. The Actor performs identifier resolution only; it does not discover related compounds.

```json
{
  "family": {
    "name": "Flintglade demo family",
    "targetIdentifiers": [{"uniprotId": "P69905"}],
    "inclusionRules": ["exact target identifier"],
    "exclusionRules": ["ambiguous target mapping"]
  },
  "compounds": [{"type": "pubchemCid", "value": "2519"}],
  "includeStructures": true,
  "includeBioactivity": false,
  "includeCoordinates": false,
  "maxActivities": 100
}
````

For bioactivity, every target needs a declared and source-consistent `chemblTargetId`, and every compound needs an exact ChEMBL molecule ID. `bioactivityFilters` explicitly names admitted assay types, quantity types, relation handling, units, organisms, and the fixed `declared_only` target scope. Up to 50,000 normalized rows are admitted. Relation operators and raw decimal strings are never overwritten.

### Output

A successful default-dataset result gives family-level counts, conflicts/refusals, source coverage, archive SHA-256 and size, verification status, artifact references, and the `molecular-dossier` billing decision. The final row is an uncharged `run-summary` with source retries, bytes, elapsed time, artifact references, accepted event count, and stop reason.

The default key-value store receives:

- `MOLECULAR_EVIDENCE_PACK.zip` — deterministic portable dossier;
- `MANIFEST.json` — byte length, SHA-256, schema version, and generation rule for each artifact;
- `VERIFICATION.json` — archive round-trip and entry-hash checks.

The ZIP contains canonical JSON, safe CSV tables, deterministic Markdown, source map, limitations, schema, checksums, and its internal manifest. CSV display cells beginning with `=`, `+`, `-`, or `@` are prefixed to prevent spreadsheet formula execution; raw JSON remains unchanged. Archive paths are generated, normalized, and checked for traversal, aliases, symlinks, executable extensions, decompression hazards, and seeded tamper.

### Pricing and charge limits

The launch event is exactly **`molecular-dossier` at $1.00 per verified dossier**. One run can emit at most one such event.

- 1 verified dossier = up to $1.00 in Actor event charges, plus platform usage shown by Apify.
- Scope rejection, target/compound ambiguity, required-source outage, rights failure, archive verification failure, internal failure, and charge-cap rejection = $0 in `molecular-dossier` events.
- The default dataset summary and all failure rows are uncharged.
- Optional sections may be absent only when the input disabled them; a requested required section cannot silently disappear into a paid result.

Before source work, the runtime asks Apify how many `molecular-dossier` events remain under the user’s cap. If fewer than one can be accepted, it emits an uncharged `charge_limit_reached` result and summary without contacting a provider. After a verified result is pushed with the event name, it checks `charged_count` and `event_charge_limit_reached`; it never assumes the event was accepted. `apify-default-dataset-item` must remain disabled, and there is no Stripe or second payment path.

The $1.00 launch price follows the approved build packet and is sensible for the controlled default. Seven evidence-heavy local Docker runs at 4 GiB/1 CPU completed 7/7 with 3.611-second p50, 4.056-second nearest-rank p95, 98.625 MiB peak RSS, and zero aborts. At the documented $0.20/CU and 20% Store commission assumptions, the conservative p95 estimate leaves $0.799099 creator net after commission and configured-memory compute. This is candidate-equivalent local evidence, not hosted performance; preserve $1.00 unless hosted evidence justifies an operator-approved change. See [PUBLICATION\_EVIDENCE.md](PUBLICATION_EVIDENCE.md).

### Stateless behavior, partial failures, and negative results

This Actor is stateless and writes no persistent baseline. A provider outage or malformed response that prevents a requested section produces an uncharged `source_error`; no partial scientific table is presented as complete. Ambiguous identity produces an uncharged, inspectable refusal. Experimental and predicted structures are always separate classes. Censored or incompatible ChEMBL rows retain relation, unit, assay, target, and organism, receive explicit comparability labels, and are never pooled.

### Resource limits

- 25 targets and 500 supplied compounds maximum;
- five RCSB entries plus one bounded AlphaFold response per target;
- 50,000 admitted activity rows maximum, paged 200 at a time;
- 5 MB JSON response and depth 40 per request;
- 100 MB verified archive maximum;
- 1 GB minimum, 4 GB default, 8 GB maximum memory;
- 1,800-second hosted timeout.

The implementation keeps only one raw source page at a time and stores normalized rows rather than retaining raw response bodies. Identical recorded evidence produces identical archive bytes; observation time, run ID, retries, and platform metadata are excluded from dossier canonical content.

### Data handling and privacy

Only declared public identifiers, family labels/rules, and source evidence are processed. Outputs remain in the run’s Apify dataset and key-value store. Flintglade receives no hidden copy, telemetry, advertising data, payment-card data, or customer secret. See [PRIVACY.md](PRIVACY.md) for retention and deletion details.

### Limitations and publication boundary

This dossier is source evidence, not universal truth. It does not assess therapeutic relevance, efficacy, safety, target validity, or a “best” structure/compound. Provider rights can vary at record level; provenance and attribution must travel with reused content.

The Actor is fully prepared for candidate upload based on all locally closable software, scientific-review, usefulness, security, reproducibility, and candidate-equivalent Docker gates. Paid demand and external researcher testimony are business validation rather than software-readiness blockers and are not claimed. Upload-time platform checks and operator approval remain in [RELEASE\_CHECKLIST.md](RELEASE_CHECKLIST.md). Do not upload, promote, or publish from this packet.

Support: `support@flintglade.com`. See [SUPPORT.md](SUPPORT.md) and [CHANGELOG.md](CHANGELOG.md).

# Actor input Schema

## `inputSchemaVersion` (type: `integer`):

Runtime contract version; does not trigger source calls or affect cost.

## `family` (type: `object`):

Required declared family scope. Each target triggers bounded UniProt and, when requested, structure-source reads. At most 25 public targets; retained in the dossier.

## `compounds` (type: `array`):

0-500 exact public identifiers. No similarity, substructure, or open-ended discovery is performed. Source calls are bounded per supplied item; values are retained in the dossier.

## `bioactivityFilters` (type: `object`):

Applied only when includeBioactivity is true. Filters narrow official ChEMBL activity reads and can change dossier size, not the one-event price.

## `includeStructures` (type: `boolean`):

When true, reads up to five declared PDB cross-references and one bounded AlphaFold DB response per target; retained in the archive; does not add events.

## `includeBioactivity` (type: `boolean`):

When true, queries only declared ChEMBL target/molecule pairs with explicit filters; up to maxActivities rows are retained; does not add events.

## `includeCoordinates` (type: `boolean`):

Version 0.1 does not copy coordinate files. Runtime validation requires false.

## `maxActivities` (type: `integer`):

1-50,000 normalized rows; bounds ChEMBL pagination and archive size; does not change the one-event price.

## `archiveFormat` (type: `string`):

Version 0.1 supports a deterministic verified ZIP only.

## `expertReviewMode` (type: `boolean`):

Required for prepublication candidate builds. Review notes are never inserted into customer archives before approval.

## Actor input object example

```json
{
  "inputSchemaVersion": 1,
  "family": {
    "name": "Flintglade demo family",
    "targetIdentifiers": [
      {
        "uniprotId": "P69905"
      }
    ],
    "inclusionRules": [
      "exact target identifier"
    ],
    "exclusionRules": [
      "ambiguous target mapping"
    ]
  },
  "compounds": [
    {
      "type": "pubchemCid",
      "value": "2519"
    }
  ],
  "includeStructures": true,
  "includeBioactivity": true,
  "includeCoordinates": false,
  "maxActivities": 10000,
  "archiveFormat": "zip",
  "expertReviewMode": true
}
```

# Actor output Schema

## `defaultDataset` (type: `string`):

No description

## `archive` (type: `string`):

No description

## `manifest` (type: `string`):

No description

## `verification` (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 = {
    "family": {
        "name": "Flintglade demo family",
        "targetIdentifiers": [
            {
                "uniprotId": "P69905"
            }
        ],
        "inclusionRules": [
            "exact target identifier"
        ],
        "exclusionRules": [
            "ambiguous target mapping"
        ]
    },
    "compounds": [
        {
            "type": "pubchemCid",
            "value": "2519"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flintglade/molecular-evidence-pack-builder").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 = {
    "family": {
        "name": "Flintglade demo family",
        "targetIdentifiers": [{ "uniprotId": "P69905" }],
        "inclusionRules": ["exact target identifier"],
        "exclusionRules": ["ambiguous target mapping"],
    },
    "compounds": [{
            "type": "pubchemCid",
            "value": "2519",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("flintglade/molecular-evidence-pack-builder").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 '{
  "family": {
    "name": "Flintglade demo family",
    "targetIdentifiers": [
      {
        "uniprotId": "P69905"
      }
    ],
    "inclusionRules": [
      "exact target identifier"
    ],
    "exclusionRules": [
      "ambiguous target mapping"
    ]
  },
  "compounds": [
    {
      "type": "pubchemCid",
      "value": "2519"
    }
  ]
}' |
apify call flintglade/molecular-evidence-pack-builder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=flintglade/molecular-evidence-pack-builder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Molecular Evidence Pack Builder",
        "description": "Build a bounded, verified molecular evidence dossier from declared public identifiers.",
        "version": "0.1",
        "x-build-id": "pnRFMv0afjyBMtFgE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/flintglade~molecular-evidence-pack-builder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-flintglade-molecular-evidence-pack-builder",
                "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/flintglade~molecular-evidence-pack-builder/runs": {
            "post": {
                "operationId": "runs-sync-flintglade-molecular-evidence-pack-builder",
                "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/flintglade~molecular-evidence-pack-builder/run-sync": {
            "post": {
                "operationId": "run-sync-flintglade-molecular-evidence-pack-builder",
                "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": [
                    "family"
                ],
                "properties": {
                    "inputSchemaVersion": {
                        "title": "Input schema version",
                        "minimum": 1,
                        "maximum": 1,
                        "type": "integer",
                        "description": "Runtime contract version; does not trigger source calls or affect cost.",
                        "default": 1
                    },
                    "family": {
                        "title": "Bounded protein or enzyme family",
                        "required": [
                            "name",
                            "targetIdentifiers",
                            "inclusionRules",
                            "exclusionRules"
                        ],
                        "type": "object",
                        "description": "Required declared family scope. Each target triggers bounded UniProt and, when requested, structure-source reads. At most 25 public targets; retained in the dossier.",
                        "properties": {
                            "name": {
                                "type": "string",
                                "title": "Family name",
                                "description": "A user label retained in outputs; 1-200 characters, for example Flintglade demo family.",
                                "minLength": 1,
                                "maxLength": 200
                            },
                            "targetIdentifiers": {
                                "type": "array",
                                "title": "Declared public targets",
                                "description": "1-25 exact UniProt accessions. Optional ChEMBL target IDs are required for bounded bioactivity queries and are checked against source evidence.",
                                "minItems": 1,
                                "maxItems": 25,
                                "items": {
                                    "type": "object",
                                    "additionalProperties": false,
                                    "properties": {
                                        "uniprotId": {
                                            "type": "string",
                                            "title": "UniProt accession",
                                            "description": "Exact public UniProtKB accession, for example P69905.",
                                            "pattern": "^[A-Za-z0-9]{6,10}$",
                                            "minLength": 6,
                                            "maxLength": 10
                                        },
                                        "chemblTargetId": {
                                            "type": "string",
                                            "title": "ChEMBL target ID",
                                            "description": "Optional exact ChEMBL target ID for bioactivity, for example CHEMBL2093866.",
                                            "pattern": "^CHEMBL[0-9]+$",
                                            "maxLength": 30
                                        }
                                    },
                                    "required": [
                                        "uniprotId"
                                    ]
                                }
                            },
                            "inclusionRules": {
                                "type": "array",
                                "title": "Inclusion rules",
                                "description": "1-25 explicit rules retained verbatim; each is at most 500 characters.",
                                "minItems": 1,
                                "maxItems": 25,
                                "items": {
                                    "type": "string",
                                    "minLength": 1,
                                    "maxLength": 500
                                }
                            },
                            "exclusionRules": {
                                "type": "array",
                                "title": "Exclusion rules",
                                "description": "1-25 explicit exclusions retained verbatim; each is at most 500 characters.",
                                "minItems": 1,
                                "maxItems": 25,
                                "items": {
                                    "type": "string",
                                    "minLength": 1,
                                    "maxLength": 500
                                }
                            }
                        },
                        "additionalProperties": false
                    },
                    "compounds": {
                        "title": "Supplied compounds",
                        "maxItems": 500,
                        "type": "array",
                        "description": "0-500 exact public identifiers. No similarity, substructure, or open-ended discovery is performed. Source calls are bounded per supplied item; values are retained in the dossier.",
                        "items": {
                            "type": "object",
                            "additionalProperties": false,
                            "properties": {
                                "type": {
                                    "type": "string",
                                    "title": "Identifier type",
                                    "description": "Select one exact public identifier namespace; this controls which bounded official lookup is made.",
                                    "enum": [
                                        "pubchemCid",
                                        "chemblId",
                                        "inchiKey",
                                        "smiles"
                                    ]
                                },
                                "value": {
                                    "type": "string",
                                    "title": "Identifier",
                                    "description": "Exact public value retained in output; 1-500 characters, for example 2519.",
                                    "minLength": 1,
                                    "maxLength": 500
                                }
                            },
                            "required": [
                                "type",
                                "value"
                            ]
                        }
                    },
                    "bioactivityFilters": {
                        "title": "Lossless ChEMBL activity admission filters",
                        "type": "object",
                        "description": "Applied only when includeBioactivity is true. Filters narrow official ChEMBL activity reads and can change dossier size, not the one-event price.",
                        "properties": {
                            "assayTypes": {
                                "type": "array",
                                "title": "Assay types",
                                "description": "Admit 1-6 exact ChEMBL assay type codes; values are retained and can reduce output size.",
                                "minItems": 1,
                                "maxItems": 6,
                                "uniqueItems": true,
                                "items": {
                                    "type": "string",
                                    "pattern": "^[BFAPTU]$"
                                },
                                "default": [
                                    "B",
                                    "F"
                                ]
                            },
                            "standardTypes": {
                                "type": "array",
                                "title": "Quantity types",
                                "description": "Admit 1-25 exact source quantity labels such as IC50; values are retained and never treated as synonyms.",
                                "minItems": 1,
                                "maxItems": 25,
                                "uniqueItems": true,
                                "items": {
                                    "type": "string",
                                    "minLength": 1,
                                    "maxLength": 100
                                },
                                "default": [
                                    "IC50",
                                    "Ki",
                                    "Kd",
                                    "EC50"
                                ]
                            },
                            "relationHandling": {
                                "type": "string",
                                "title": "Relation handling",
                                "description": "preserve retains censored operators and refuses pooling; exact_only excludes them.",
                                "enum": [
                                    "preserve",
                                    "exact_only"
                                ],
                                "default": "preserve"
                            },
                            "units": {
                                "type": "array",
                                "title": "Allowed source units",
                                "description": "Admit 1-20 exact source units; no hidden unit conversion is performed.",
                                "minItems": 1,
                                "maxItems": 20,
                                "uniqueItems": true,
                                "items": {
                                    "type": "string",
                                    "minLength": 1,
                                    "maxLength": 100
                                },
                                "default": [
                                    "nM"
                                ]
                            },
                            "organisms": {
                                "type": "array",
                                "title": "Allowed target organisms",
                                "description": "Optionally admit up to 25 exact source organism strings; empty keeps all declared-target organisms.",
                                "maxItems": 25,
                                "uniqueItems": true,
                                "items": {
                                    "type": "string",
                                    "minLength": 1,
                                    "maxLength": 100
                                },
                                "default": []
                            },
                            "targetScope": {
                                "type": "string",
                                "title": "Target scope",
                                "description": "Version 0.1 can query only exact targets declared in family.targetIdentifiers.",
                                "enum": [
                                    "declared_only"
                                ],
                                "default": "declared_only"
                            }
                        },
                        "additionalProperties": false
                    },
                    "includeStructures": {
                        "title": "Include structure evidence",
                        "type": "boolean",
                        "description": "When true, reads up to five declared PDB cross-references and one bounded AlphaFold DB response per target; retained in the archive; does not add events.",
                        "default": true
                    },
                    "includeBioactivity": {
                        "title": "Include admitted bioactivity",
                        "type": "boolean",
                        "description": "When true, queries only declared ChEMBL target/molecule pairs with explicit filters; up to maxActivities rows are retained; does not add events.",
                        "default": true
                    },
                    "includeCoordinates": {
                        "title": "Include coordinates",
                        "type": "boolean",
                        "description": "Version 0.1 does not copy coordinate files. Runtime validation requires false.",
                        "default": false
                    },
                    "maxActivities": {
                        "title": "Maximum admitted activities",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "1-50,000 normalized rows; bounds ChEMBL pagination and archive size; does not change the one-event price.",
                        "default": 10000
                    },
                    "archiveFormat": {
                        "title": "Archive format",
                        "enum": [
                            "zip"
                        ],
                        "type": "string",
                        "description": "Version 0.1 supports a deterministic verified ZIP only.",
                        "default": "zip"
                    },
                    "expertReviewMode": {
                        "title": "Expert review mode",
                        "type": "boolean",
                        "description": "Required for prepublication candidate builds. Review notes are never inserted into customer archives before approval.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
