# Foundry API Source: https://docs.adaptyvbio.com/api-reference/api-introduction Submit protein sequences for experimental characterization and retrieve results programmatically. The Foundry API connects your computational pipeline to Adaptyv Bio's protein testing platform. You submit sequences, the lab runs experiments, and you retrieve binding data, thermostability measurements, or expression levels via a simple webhook. ## How to Connect You or your agent can find all information via ``` curl https://devs.adaptyvbio.com/api/v1/openapi.json ``` Every request aside from getting the `openapi.json` requires a bearer token: ```bash theme={null} curl https://devs.adaptyvbio.com/api/v1/targets?limit=3 \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" ``` Tokens are scoped to your organization and role. See [Getting an API token](#getting-an-api-token) below for the full walkthrough, and always store your token in an environment variable rather than committing it to source control. ## Getting an API token API tokens live in the [Foundry portal](https://foundry.adaptyvbio.com/) under **Organization → Settings → Tokens**. Existing tokens for your organization show their owner, role, status, creation date, and expiry. The **Create Token** button is in the top right. Foundry portal screenshot: the API Tokens settings page, showing the list of existing tokens (name, owner, role, status, created and expires dates) and the Create Token button. Creating a token asks for three things: a name (for your own bookkeeping), a role, and an expiry. Pick **Member** if you need to create or modify experiments, **Viewer** for read-only access. Expiry runs from seven days to one year; pick the shortest window that still covers your use case. Foundry portal screenshot: the Create API Token modal, with fields for name, role (Member or Viewer), and expiry (7 days, 30 days, 90 days, 1 year). The token value is shown once, at creation time. Copy it before closing the dialog — Adaptyv only stores a revocation ID, not the token itself, and there is no way to retrieve it later. Revoking a token from the same page invalidates it immediately for both REST API and MCP use. ## What the API covers The API exposes five resource groups. Together, they support the full experiment lifecycle: browse targets, submit sequences, track progress, and collect results. **Targets:** Browse [our catalog](https://targets.adaptyvbio.com/) of available target antigens programmatically. You can filter by name, vendor, or self-service availability. Targets for which we have a calibrated self-service price allow instant cost estimates and automated checkout. **Experiments:** Create experiments by specifying a target and one or more protein sequences. Five experiment types are available: | Type | What it measures | Requires target | | - | - | - | | `screening` | Binding yes/no against a target antigen (BLI or SPR) | Yes | | `affinity` | Binding kinetics: K\_D, k\_on, k\_off (BLI or SPR) | Yes | | `thermostability` | Melting temperature via differential scanning fluorimetry | No | | `fluorescence` | Fluorescence intensity of protein variants | No | | `expression` | Expression yield of protein constructs | No | For more information about each see [the experiment types documentation](https://docs.adaptyvbio.com/docs/experiment-types/). **Sequences:** List, inspect, and add sequences to draft experiments. Each sequence is a single amino acid string; multi-chain formats (Fab heavy:light) use a colon separator. **Results:** Retrieve experimental data once the lab completes your run. Results include binding classifications, kinetic constants, melting temperatures, or expression levels, depending on experiment type. **Quotes and invoices:** Review pricing, confirm quotes, and access invoices for your experiments. ## Experiment lifecycle The diagram below shows how an experiment moves from draft to delivered results. You control the transitions on the left (create, submit, confirm); everything on the right happens in the lab. ```mermaid theme={null} sequenceDiagram participant You as You (API caller) participant API as Foundry API participant Lab as Adaptyv Lab Note over You,Lab: 1. Design & draft You->>API: POST /experiments API-->>You: experiment_id, status: Draft Note over You: Edit freely — add sequences,
change target, adjust parameters You->>API: PATCH /experiments/{id} API-->>You: updated Note over You,Lab: 2. Submit for review You->>API: POST /experiments/{id}/submit API-->>You: status: WaitingForConfirmation Lab->>API: Review experiment, prepare quote API-->>You: status: QuoteSent Note over You,Lab: 3. Quote & confirm You->>API: GET /experiments/{id}/quote API-->>You: line items, total, PDF link You->>API: POST /quotes/{id}/confirm API-->>You: status: WaitingForMaterials Note over You,Lab: 4. Lab processing (5–15 days) Lab->>API: Order gene fragments & target API-->>You: status: WaitingForMaterials Lab->>API: Materials arrive, begin assay API-->>You: status: InProduction Lab->>API: Raw data collected API-->>You: status: DataAnalysis Lab->>API: QC complete API-->>You: status: InReview Note over You,Lab: 5. Results Lab->>API: Results released API-->>You: status: Done You->>API: GET /experiments/{id}/results API-->>You: binding data, kinetics, Tm, … ``` **API status values** and what they mean: | Status | Who acts | What is happening | | - | - | - | | `Draft` | You | Experiment is editable. No cost commitment. | | `WaitingForConfirmation` | Adaptyv | Under review; quote is being prepared. | | `QuoteSent` | You | Quote ready — review and confirm to proceed. | | `WaitingForMaterials` | Adaptyv | Gene fragments and target antigen ordered. | | `InQueue` | Adaptyv | Materials arrived; queued for the lab. | | `InProduction` | Adaptyv | Assay running. | | `DataAnalysis` | Adaptyv | Raw data processing and QC. | | `InReview` | Adaptyv | Final validation before release. | | `Done` | You | Results available via the API. | | `Canceled` | Either | Experiment canceled (possible from Draft or WaitingForConfirmation). | You can poll status at any time with `GET /experiments/{id}`. The `results_status` field tells you whether results are `none`, `partial`, or `all` without fetching the full dataset. To receive push notifications instead of polling, pass a `webhook_url` when creating the experiment. ## Quick example This snippet creates a binding screen against a target from the catalog: ```bash theme={null} export FOUNDRY_API_URL="https://devs.adaptyvbio.com/api/v1/openapi.json" # 1. Find a target curl "$FOUNDRY_API_URL/targets?search=EGFR&selfservice_only=true&limit=1" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" # Response includes target_id, pricing, and catalog details ``` ```bash theme={null} # 2. Create the experiment curl -X POST "$FOUNDRY_API_URL/experiments" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "EGFR Binding Screen — Round 3", "experiment_spec": { "experiment_type": "screening", "method": "bli", "target_id": "019a03da-b87f-7902-81d5-24da9754bdde", "sequences": { "candidate_1": "EVQLVESGGGLVQPGGSLRLSCAASGFNIKDTYIHWVRQAPGKGLEWVARIYPTNGYTRYADSVKGRFTISADTSKNTAYLQMNSLRAEDTAVYYCSRWGGDGFYAMDYWGQGTLVTVSS", "candidate_2": "QVQLVQSGAEVKKPGASVKVSCKASGYTFTNYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARGGYSSSWYFDYWGQGTLVTVSS" } } }' # Response: # { # "experiment_id": "019d4a2b-...", # "experiment_code": "ORG-001-123", # "status": "draft", # "costs": { ... } # } ``` ```bash theme={null} # 3. Submit for processing curl -X POST "$FOUNDRY_API_URL/experiments/019d4a2b-.../submit" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" ``` ```bash theme={null} # 4. Check results (once the experiment reaches "done") curl "$FOUNDRY_API_URL/experiments/019d4a2b-.../results" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" ``` ## Filtering and sorting List endpoints accept `filter`, `sort`, and `search` query parameters. **Filtering** uses an s-expression syntax, in order to make it easier for you (and your agents) to compose complex filter conditions. Wrap the expression in the `filter` parameter: ``` GET /experiments?filter=eq(status,"draft") GET /experiments?filter=and(eq(status,"done"),gte(created_at,"2026-01-01")) ``` Available operators: `eq`, `neq`, `gt`, `gte`, `lt`, `lte`, `contains`, `between`, `in`, `is_null`, `is_not_null`. Combine with `and`, `or`, `not`. **Sorting** uses `asc(field)` or `desc(field)`: ``` GET /experiments?sort=desc(created_at) GET /results?sort=asc(created_at),desc(binding_score) ``` **Search** is a free-text substring match on name fields: ``` GET /targets?search=HER2 ``` **Pagination** uses `limit` (1--100, default 50) and `offset` as usual: ``` GET /experiments?limit=10&offset=20 ``` ## Webhooks Register a `webhook_url` when you create an experiment to receive push notifications instead of polling: ```json theme={null} { "name": "Screen with webhook", "webhook_url": "https://your-server.com/foundry-hook", "experiment_spec": { ... } } ``` When you set a `webhook_url` on an experiment, you receive an `experiment_update` POST for every customer-facing update we post to that experiment — the same updates that trigger an email notification. Each delivery is an HTTP `POST` with this body: ```json theme={null} { "delivery_id": "019b8da3-4a91-16c6-fa94-619212bee6a6", "event": "experiment_update", "timestamp": "2026-07-01T14:30:00Z", "api_version": "2026-02", "data": { "type": "experiment.update", "experiment_id": "019d4a2b-2b7e-7c3a-9f1e-2a4b6c8d0e1f", "experiment_code": "ORG-001-123", "organization_id": "11111111-1111-1111-1111-111111111111", "update_id": "019d4a2c-3c8f-7d4b-a02f-3b5c7d9e1f20", "name": "Materials received", "description": "Your target protein arrived and QC passed.", "update_type": "progress", "eta": "2026-07-15T00:00:00Z", "created_at": "2026-07-01T14:30:00Z" } } ``` ### Verifying deliveries Every request carries these headers: | Header | Meaning | | - | - | | `X-Adaptyv-Event` | Event slug (e.g. `experiment_update`) | | `X-Adaptyv-Delivery-Id` | Unique id for this delivery attempt | | `X-Adaptyv-Signature` | `sha256=` HMAC-SHA256 of the raw request body | Verify the signature over the raw body with your webhook secret before trusting a payload: ```python theme={null} import hashlib, hmac def is_valid(raw_body: bytes, secret: str, header: str) -> bool: expected = "sha256=" + hmac.new(secret.encode(), raw_body, hashlib.sha256).hexdigest() return hmac.compare_digest(expected, header) ``` Respond with a `2xx` to acknowledge. Deliveries are retried up to 3 times with exponential backoff on network errors and `5xx` responses; a `4xx` is treated as permanent and not retried. ## Cost estimates Before committing to an experiment, you can get a cost estimate: ```bash theme={null} curl -X POST "$FOUNDRY_API_URL/experiments/cost-estimate" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "experiment_spec": { "experiment_type": "screening", "method": "bli", "target_id": "019a03da-b87f-7902-81d5-24da9754bdde", "sequences": { "s1": "EVQLVESGGGLVQPGG..." } } }' ``` The response breaks down assay costs and material costs separately, in USD cents. ## SDKs Official Python SDK: [`adaptyv-sdk`](https://github.com/adaptyvbio/adaptyv-sdk). ```python theme={null} from adaptyv_sdk import AdaptyvClient import os client = AdaptyvClient(api_key=os.environ["ADAPTYVBIO_API_TOKEN"]) experiments = client.experiments.list(limit=5) ``` ## Using the API from Claude and other AI assistants The same endpoints are exposed as MCP tools at `https://mcp.adaptyvbio.com/mcp/`. Point Claude Code, Claude Desktop, Cursor, or your own MCP-aware client at that URL with your Foundry token in the `Authorization` header, and the agent calls the API for you in plain English. See [MCP Server](/api-reference/mcp-server) for the connection details and a walkthrough of what it enables. # Accept an experiment's quote and create an invoice Source: https://docs.adaptyvbio.com/api-reference/experiments/accept-an-experiments-quote-and-create-an-invoice https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/experiments/{experiment_id}/quote/confirm A JSON body is required. Every field of `ConfirmQuoteRequest` is optional, so a caller with no purchase-order number and no notes sends `{}` — the refusal says so if they forget (BUG-0059). Convenience endpoint that does the same thing as `POST /quotes/{id}/confirm` but addressed by experiment ID — the server resolves the quote ID internally. Like `/quotes/{id}/confirm`, it is **categorically non-settling**: it finalizes the (open, unpaid) invoice and returns `200` + the invoice + a HATEOAS `payment` pointer (the Stripe-hosted page for async; `/invoices/{id}/pay` for a machine rail). It never settles or emits a payment `402`. # Create experiment Source: https://docs.adaptyvbio.com/api-reference/experiments/create-experiment https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/experiments Creates a new experiment request for the Adaptyv Foundry platform. The payload captures the target (from the catalog), antibody sequences, replicate plan, assay parameters, optional metadata, and an optional webhook for notifications. By default, experiments are created in Draft status so clients can review inputs before submission. Set `skip_draft: true` to bypass Draft status and submit directly for processing. This is useful for automated pipelines with pre-validated payloads that don't require manual review. The experiment will be created in "Waiting for confirmation" status instead of Draft. API-originated experiments are automatically assigned to the organization's API submissions project for traceability. # ExperimentSpec fields Validation is strict: fields that are not applicable to a given experiment type (e.g., `method` on a non-binding type) cause a 400 rejection. Multiple validation errors are accumulated and returned together so callers can fix everything in one round-trip. | Field | Type | Description | |-------|------|-------------| | `experiment_type` | string | **Required.** One of `affinity`, `screening`, `thermostability`, `fluorescence`, `expression`, `epitope_binning`, `enzyme_activity`. | | `method` | string | Required for `affinity`/`screening` (`bli` or `spr`). **Rejected** for all other types. | | `target_id` | string | Target UUID from the catalog. Required for `affinity`, `screening`, and `epitope_binning`. **Rejected** for non-binding types. | | `sequences` | object | **Required.** Map of sequence name to amino acid string. `epitope_binning` requires exactly 4-28 sequences in multiples of 4. | | `n_replicates` | integer | Optional for most types (default 3, range 1-5). **Rejected** for `epitope_binning`. | | `antigen_concentrations` | array | `affinity` only; optional, defaults to `[1000.0, 316.2, 100.0, 31.6, 0.0]` nM. | | `parameters` | object | Optional. Experiment-specific settings | # Sequence Formats The `sequences` field accepts two formats: **Simple format** — amino acid string only: ```json "sequences": { "seq1": "EVQLVESGGGLVQPGGSLRLSCAAS" } ``` **Object format** — with metadata: ```json "sequences": { "seq1": { "aa_string": "EVQLVESGGGLVQPGGSLRLSCAAS", "control": false, "metadata": { "type": "scfv", "tag_location": "C" } } } ``` # Example: Affinity (BLI) Full kinetic characterization measuring on/off rates and KD. Target ID `019a03da-b87f-7e15-8b02-cef171c9871d` is Human PD-L1 from the catalog. ```json { "name": "PD-L1 affinity panel", "experiment_spec": { "experiment_type": "affinity", "method": "bli", "target_id": "019a03da-b87f-7e15-8b02-cef171c9871d", "sequences": { "pembrolizumab_vh": "QVQLVQSGVEVKKPGASVKVSCKASGYTFTNYYMYWVRQAPGQGLEWMGGINPSNGGTNFNEKFKNRVTLTTDSSTTTAYMELKSLQFDDTAVYYCARRDYRFDMGFDYWGQGTTVTVSS", "pembrolizumab_vl": "EIVLTQSPATLSLSPGERATLSCRASKGVSTSGYSYLHWYQQKPGQAPRLLIYLASYLESGVPARFSGSGSGTDFTLTISSLEPEDFAVYYCQHSRDLPLTFGGGTKVEIK" }, "n_replicates": 3, "antigen_concentrations": [1000.0, 316.2, 100.0, 31.6, 0.0] }, "webhook_url": "https://example.com/webhook" } ``` # Example: Screening (SPR) High-throughput yes/no binding assessment using SPR. ```json { "name": "Library screening round 1", "experiment_spec": { "experiment_type": "screening", "method": "spr", "target_id": "019a03da-b87f-7e15-8b02-cef171c9871d", "sequences": { "clone_A1": "EVQLVESGGGLVQPGGSLRLSCAASGFTFSSYAMSWVRQAPGKGLEWVSAISGSGGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAKDRLSITIRPRYYGLDVWGQGTLVTVSS", "clone_A2": "QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARDVGYCTDYSCYFDYWGQGTLVTVSS", "clone_A3": "EVQLLESGGGLVQPGGSLRLSCAASGFTFSTYAMSWVRQAPGKGLEWVSSISSGGSYIYYADSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCARRPWGYYALDIWGQGTTVTVSS" }, "n_replicates": 2 } } ``` # Example: Thermostability Measures melting temperature (Tm) via differential scanning fluorimetry. No target required. ```json { "name": "Lead candidates stability", "experiment_spec": { "experiment_type": "thermostability", "sequences": { "candidate_1": "QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYAMHWVRQAPGQRLEWMGWINAGNGNTKYSQKFQGRVTITRDTSASTAYMELSSLRSEDTAVYYCARAKFGATGAFDIWGQGTMVTVSS", "candidate_2": "EVQLVESGGGLVQPGGSLRLSCAASGFNIKDTYIHWVRQAPGKGLEWVARIYPTNGYTRYADSVKGRFTISADTSKNTAYLQMNSLRAEDTAVYYCSRWGGDGFYAMDYWGQGTLVTVSS" }, "n_replicates": 3, "parameters": { "buffer": "PBS", "ph": 7.4 } } } ``` # Example: Fluorescence Fluorescence-based protein characterization measuring intrinsic properties. No target required. ```json { "name": "Fluorescence characterization", "experiment_spec": { "experiment_type": "fluorescence", "sequences": { "variant_1": "QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYDINWVRQATGQGLEWMGWMNPNSGNTGYAQKFQGRVTMTRDTSISTAYMELRSLRSDDTAVYYCARGGFYGSTIWFDYWGQGTLVTVSS", "variant_2": "EVQLVESGGGLVQPGGSLRLSCAASGFTFSSYWMSWVRQAPGKGLEWVANIKQDGSEKYYVDSVKGRFTISRDNAKNSLYLQMNSLRAEDTAVYYCARDRYGNYVDYWGQGTLVTVSS" }, "n_replicates": 3 } } ``` # Example: Expression Protein expression screening measuring yield and quality. No target required. ```json { "name": "Expression screening", "experiment_spec": { "experiment_type": "expression", "sequences": { "construct_A": "QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYGISWVRQAPGQGLEWMGWISAYNGNTNYAQKLQGRVTMTTDTSTSTAYMELRSLRSDDTAVYYCARDVGYCTDYSCYFDYWGQGTLVTVSS", "construct_B": "EVQLVESGGGLVQPGGSLRLSCAASGFNIKDTYIHWVRQAPGKGLEWVARIYPTNGYTRYADSVKGRFTISADTSKNTAYLQMNSLRAEDTAVYYCSRWGGDGFYAMDYWGQGTLVTVSS" }, "n_replicates": 2 } } ``` # Example: With skip_draft=true (Auto-Submit) Bypass Draft status and submit directly for processing: ```json { "name": "Pre-validated batch", "skip_draft": true, "experiment_spec": { "experiment_type": "thermostability", "sequences": { "seq1": "EVQLVESGGGLVQPGGSLRLSCAASGFTFSSYAMSWVRQAPGKGLEWVSAISGSGGSTYYADSVKGRFTISRDNSKNTLYLQMNSLRAEDTAVYYCAKDRLSITIRPRYYGLDVWGQGTLVTVSS" }, "n_replicates": 2 } } ``` # Estimate experiment cost Source: https://docs.adaptyvbio.com/api-reference/experiments/estimate-experiment-cost https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/experiments/cost-estimate Calculates the estimated cost for an experiment without creating it. Useful for previewing costs before submission. # Request Body Accepts an `experiment_spec` matching the creation endpoint format: ```json { "experiment_spec": { "experiment_type": "screening", "method": "bli", "target_id": "019a03da-b87f-7e15-8b02-cef171c9871d", "sequences": { "seq1": "MKTL...", "seq2": "EVQL..." }, "n_replicates": 3 } } ``` # Response Returns a detailed cost breakdown including: - `pricing_version`: The pricing rules applied (e.g., "v1_2026-01-20") - `assay`: Per-experiment-type costs with base and replicate pricing - `materials`: Target material costs (for binding experiments) - `total_cents`: Sum of all costs in USD cents # Complete Estimate Response When the target has self-service pricing: ```json { "breakdown": { "pricing_version": "v1_2026-01-20", "assay": { "name": "screening", "base_cents": 14900, "replicate_addon_cents": 5800, "subtotal_cents": 103500 }, "materials": { "target": { "name": "Human PD-L1", "target_catalog_id": "019a03da-b87f-7e15-8b02-cef171c9871d" }, "price_per_sequence_cents": 500, "subtotal_cents": 2500 }, "total_cents": 106000 }, "incomplete": null, "warnings": [] } ``` # Incomplete Estimate Response When the target lacks self-service pricing (e.g., custom proteins), you'll receive an incomplete estimate with assay costs but `materials_unavailable`: ```json { "breakdown": null, "incomplete": { "pricing_version": "v1_2026-01-20", "assay": { "name": "screening", "base_cents": 14900, "replicate_addon_cents": 5800, "subtotal_cents": 103500 }, "materials_unavailable": { "target": { "name": "This target", "target_catalog_id": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }, "reason": "This target is not yet onboarded to self-service pricing. You'll receive a quote with full price information." } }, "warnings": [] } ``` Use `GET /targets?selfservice_only=true` to list targets with complete pricing. # Notes - **All prices exclude VAT**; taxes calculated at invoicing based on jurisdiction - Requires authentication with experiment read permission - Does not create an experiment - Pricing is based on the current date (not a future experiment date) - Targets without self-service pricing return incomplete estimates (not errors) - Experiments created before pricing v1 (2026-01-20) cannot be estimated # Get experiment Source: https://docs.adaptyvbio.com/api-reference/experiments/get-experiment https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/experiments/{experiment_id} Returns full metadata for an experiment: workflow status, target and sequence details, assay parameters, and billing references. Poll this endpoint to track progress. When `stripe_quote_url` appears, fetch quote details via `/experiments/{id}/quote`. After confirmation, `stripe_invoice_url` provides a direct link to the invoice. The `results_status` field signals data availability: `None` (pending), `Partial` (preliminary), or `All` (complete). Query `/results` filtered by experiment to retrieve data once results are available. # Get experiment invoice Source: https://docs.adaptyvbio.com/api-reference/experiments/get-experiment-invoice https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/experiments/{experiment_id}/invoice Returns invoice metadata for a confirmed experiment, including the hosted payment URL. Available once `stripe_invoice_url` appears in the experiment detail; timing depends on organization billing settings. An invoice exists only after the quote has been accepted. Until then this returns `404`, and the message names the confirm call to make instead of polling here. # Get experiment quote Source: https://docs.adaptyvbio.com/api-reference/experiments/get-experiment-quote https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/experiments/{experiment_id}/quote Returns quote metadata: totals, currency, status, and expiration. The `expires_at` field shows when the quote expires if not confirmed. **The quote is generated asynchronously, so poll this endpoint.** `POST /experiments/{experiment_id}/submit` returns before the quote exists; generating it involves a call to the payment provider. Until it lands this endpoint answers `404`, which means *not yet* rather than *never* — the same contract `GET /experiments/{experiment_id}/invoice` follows. A `404` here is an expected step in the normal flow, not an error to report. Poll until `200`, or equivalently until `stripe_quote_id` appears on `GET /experiments/{experiment_id}`. A second or two is typical. Distinguish the two `404` causes by the experiment's own status: an experiment still in `draft` has not been submitted, so no quote is coming until it is. # Get experiment quote PDF Source: https://docs.adaptyvbio.com/api-reference/experiments/get-experiment-quote-pdf https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/experiments/{experiment_id}/quote/pdf Returns the quote as a PDF containing itemized pricing, terms, and experiment configuration. Response content-type is `application/pdf`. # List experiment updates Source: https://docs.adaptyvbio.com/api-reference/experiments/list-experiment-updates https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/experiments/{experiment_id}/updates Returns updates for one experiment, oldest first (chronological). Update types include `status_change`, `progress`, and `error`. Filter by type using `filter=eq(type,status_change)`. # List experiments Source: https://docs.adaptyvbio.com/api-reference/experiments/list-experiments https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/experiments Lists experiments accessible to the caller, sorted by creation date (newest first). Experiments progress from submission through review, production, and analysis until results are available. The response includes only experiments within the caller's organization scope. Filter by `status` for specific workflow stages, by `state` for broader groupings, or by `search` for name/code substring matches. Date operators (`lte`, `gte`, `lt`, `gt`, `eq`) accept ISO 8601 dates or timestamps via `filter=` s-expression. Paginate with `limit` and `offset`; fetch pages until fewer than `limit` items return. # List results for an experiment Source: https://docs.adaptyvbio.com/api-reference/experiments/list-results-for-an-experiment https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/experiments/{experiment_id}/results Returns all analysis results associated with a specific experiment. Results appear when the experiment's `results_status` field reaches `Partial` or `All`. Supports pagination via `limit` and `offset` query parameters. Use this endpoint when you need results for a single experiment without filtering the global `/results` list. The response includes the same `ResultInfo` structure as the global endpoint, scoped to the specified experiment. # List sequences for an experiment Source: https://docs.adaptyvbio.com/api-reference/experiments/list-sequences-for-an-experiment https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/experiments/{experiment_id}/sequences Returns all sequences associated with a specific experiment. Results are sorted by creation date (newest first) and can be searched by name or amino acid content. Supports pagination via `limit` and `offset` query parameters. For sequences from a single experiment without filtering the global `/sequences` list. Returns `SequenceListItem` records scoped to the specified experiment. # Submit experiment Source: https://docs.adaptyvbio.com/api-reference/experiments/submit-experiment https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/experiments/{experiment_id}/submit Submits a draft experiment for review. Advances from Draft to WaitingForConfirmation by finalizing the Stripe quote. To accept an already-submitted quote, use `POST /experiments/{id}/quote/confirm`. # Update experiment Source: https://docs.adaptyvbio.com/api-reference/experiments/update-experiment https://devs.adaptyvbio.com/api/v1/openapi.json patch /api/v1/experiments/{experiment_id} Modify an existing experiment's configuration or status. Updates experiment metadata or inputs. Most fields can only be changed while the experiment is in Draft or InReview status; naming one on a later status returns 409 Conflict. `webhook_url` is the exception and stays editable for the life of the experiment, so a customer can repoint delivery after submitting. # Submit feedback, bug reports, or feature requests Source: https://docs.adaptyvbio.com/api-reference/feedback/submit-feedback-bug-reports-or-feature-requests https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/feedback/submit Use this endpoint to give us feedback, report bugs that are not already caught by our observability, or request features (or have your agents do it). # Request Provide: - `request_uuid`: The UUID from the problematic API request - `feedback_type`: `feature_request`, `feedback`, or `bug_report` - `title`: Optional short title (defaults to a timestamp + organization name) - At least one of (can provide both): - `json_body`: Structured error details as JSON - `human_note`: Free-form text description # Database connectivity probe Source: https://docs.adaptyvbio.com/api-reference/info/database-connectivity-probe https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/info/health-db Verifies database connectivity by executing a trivial query. Returns 200 when the database is reachable, 503 when it is not. # Liveness probe Source: https://docs.adaptyvbio.com/api-reference/info/liveness-probe https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/info/health Returns 200 when the service is alive. No authentication required. No database interaction. # Integrator & Partner Guide Source: https://docs.adaptyvbio.com/api-reference/integrator-partner-guide How to integrate the Foundry API into your platform with a BYOK flow, and when to apply to the Partner Program. The [Foundry API](/api-reference/api-introduction) aims to make wetlab data requests as simple as a (somewhat slow) Modal call or DB query. We want all of our users to have access to this capability and their results data in all of their tools, and to make it easy for developers to build rich applications on top of our API, or enrich their existing apps with our lab capabilities. ## How to integrate: BYOK flows only The beauty of APIs vs. integrations is that they allow flexibility, for the providers, developers, and the users. To maintain this flexibility, and because wetlab work requires a tight feedback loop (see [Service providers and reselling](#service-providers-and-reselling) below), we require you to implement a **B**ring **Y**our **O**wn **K**ey (`BYOK`) flow. This is a common pattern for AI model providers, where users choose which account(s) they want to link to your platform by pasting their scoped API keys. This means you must not "bundle" user orders under your own key — instead, the user should provide the token they received from the [Foundry portal](https://foundry.adaptyvbio.com/) (or, if you are a [partner](https://www.adaptyvbio.com/api/apply) who has onboarded them, the token you have minted for them). Screenshot of a third-party settings page where the user pastes a scoped Adaptyv API key, illustrating the BYOK pattern. Since the keys allow all the actions of their owner (modulo attenuation), for security purposes you must never store them as plain text. In descending order of priority and security, we recommend: 1. Don't store them at all — prompt the user for the key each session. 2. Store them encrypted client-side. 3. If you must persist them, store them encrypted server-side. If you hold the keys for the users on your servers, we encourage you to attenuate tokens down to the minimal required permissions for the actions your integration performs. You can send users to the Foundry token creation screen directly via [`https://foundry.adaptyvbio.com/request-token`](https://foundry.adaptyvbio.com/request-token) to streamline adding the token. To streamline even further, you can apply to our [Partner Program](https://www.adaptyvbio.com/api/apply). ## Partner tokens Screenshot of the Foundry portal showing the partner-token creation interface. If you are accepted into our [Partner Program](https://www.adaptyvbio.com/api/apply), you gain the ability to create keys with the partner role. These keys allow you to call the partner-only routes — currently just one: * `POST /api/v1/partners/mint-token` — mint a user token for a customer. * With `org.type: "new_org"`: bootstrap a new organization (when the customer's email domain has no org on our platform yet) and create its first user. * With `org.type: "existing_org"`: add a new user and mint their token inside an org you previously onboarded. * Users must be new — an existing email is rejected with `409`. Tokens default to a 90-day expiry; pass `expires_at` to override. Partner tokens should be kept safe and stored separately from your own API keys used for data access. The `mint-token` action lets you create tokens for users that do not yet have any organization (as determined by their email domain) on our platform. You can also add users to organizations you have onboarded, or mint additional tokens for users that belong to those organizations. For customers you have not onboarded, you can request a token via [`https://foundry.adaptyvbio.com/request-token`](https://foundry.adaptyvbio.com/request-token), which triggers a pre-filled version of our [standard token creation flow](/api-reference/api-introduction#getting-an-api-token). The user can then copy and paste the token into your platform as in any non-partner BYOK flow (see above). Per the partner agreement, you may not use any of these tokens except on behalf of the user (for example, placing orders or accessing their data outside of providing them services). If you need service tokens for agents, you should attenuate existing user tokens appropriately. For details on the partner-only API calls, fetch the OpenAPI spec while authenticating with your partner token: ```bash theme={null} curl -H "Authorization: Bearer $PARTNER_TOKEN" \ https://devs.adaptyvbio.com/api/v1/openapi.json ``` The returned JSON will describe the partner-exclusive routes in more detail. ## Service providers and reselling We distinguish service providers and resellers based on who the end consumer of the data from our API is — both in terms of billing and in terms of who actually consumes the data. If you are running a campaign on behalf of a customer, and they never (want to) see the raw data but are only interested in the final IP, then you probably qualify as a **service provider**, especially if you have discretion over the budget of the campaign. If the customer retains day-to-day control over the budget (instead of, e.g., delegating you a lump sum) and/or wants to review the raw data themselves, then *they* are the actual data consumer and we would classify you as a **reseller** or **distributor**. For reselling and distribution, you must apply to the [Partner Program](https://www.adaptyvbio.com/api/apply) and either manage your customers' tokens for them or request that they give you access via their existing tokens. We need a direct relationship with the data consumer because, during an experiment, a lot can change. Due to the nature of biology, ordered sequences might not express, initial data might show that running more replicates to get exact $K_d$ estimates is pointless, or additional runs might be required. We need to be able to communicate directly with the data users to sort these things out and to adjust the order and invoicing accordingly. Even if you are a service provider under this definition, we strongly encourage applying to the [Partner Program](https://www.adaptyvbio.com/api/apply) and provisioning keys for your customers. It makes it much easier for us to respond to any follow-up questions the customers might have, and it makes it easier for you to manage the blast radius of any integration you build. ### Which bucket are you in? ```mermaid theme={null} flowchart TD Start([You want to integrate with the
Adaptyv API on behalf of customers]) --> Q1{Does the customer ever
want to see the raw data?} Q1 -->|Yes — they review
the raw data themselves| Reseller Q1 -->|No — they only care
about the final IP| Q2{Do you have discretion
over the campaign budget?} Q2 -->|No — customer retains
day-to-day budget control| Reseller Q2 -->|Yes — customer
delegates a lump sum| ServiceProvider Reseller[Reseller / Distributor]:::rs ServiceProvider[Service Provider]:::sp Reseller --> RSNext["Partner Program required.

Manage customer tokens for them,
or request access via their tokens.

Adaptyv needs a direct relationship
with the data consumer to handle
mid-experiment changes and invoicing."]:::rsAction ServiceProvider --> SPNext["Standard BYOK flow is sufficient.

Users paste their scoped API keys
via foundry.adaptyvbio.com/request-token.

Strongly encouraged: apply to the
Partner Program to provision keys for
customers — easier follow-ups and
smaller blast radius."]:::spAction classDef sp fill:#d4edda,stroke:#28a745,stroke-width:2px,color:#155724 classDef rs fill:#fff3cd,stroke:#ffc107,stroke-width:2px,color:#856404 classDef spAction fill:#f8f9fa,stroke:#28a745,stroke-width:1px,color:#212529 classDef rsAction fill:#f8f9fa,stroke:#ffc107,stroke-width:1px,color:#212529 ``` ## Next steps REST endpoints, authentication, and the experiment lifecycle. Drive the same endpoints from Claude, Cursor, or any MCP-aware client. Mint tokens for your customers and unlock partner-only routes. Create and manage API tokens, organizations, and users. # Get invoice Source: https://docs.adaptyvbio.com/api-reference/invoices/get-invoice https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/invoices/{invoice_id} Fetches a single invoice by its Foundry UUID or Stripe invoice ID (`in_xxx`). The caller's org membership scopes visibility — an invoice belonging to an org the caller cannot access returns 404. # Get invoice PDF Source: https://docs.adaptyvbio.com/api-reference/invoices/get-invoice-pdf https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/invoices/{invoice_id}/pdf Redirects (307) to the Stripe-hosted PDF for the given invoice. The PDF is only available after the invoice has been finalized (status `open` or `paid`). Requesting a PDF for a `draft` invoice returns 404 — finalize the invoice first by submitting and confirming the associated quote. The PDF URL is fetched live from Stripe on every request; clients should follow the redirect immediately rather than caching it. # List invoices Source: https://docs.adaptyvbio.com/api-reference/invoices/list-invoices https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/invoices Lists every invoice generated for the caller's organization so clients can display billing history, monitor outstanding balances, and reconcile payments. Results are sorted by creation date by default and include due dates, currency, and current status for each invoice. # Pay invoice Source: https://docs.adaptyvbio.com/api-reference/invoices/pay-invoice https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/invoices/{invoice_id}/pay Settles the given invoice. How it settles is chosen by the `X-Adaptyv-Payment-Method` request header: | Header value | Behaviour | |---|---| | _(absent)_ | Returns the current invoice state; pay via the hosted invoice URL. If the quote was pinned to a crypto rail at experiment creation, returns `409` — retry with the `X-Adaptyv-Payment-Method` header used at creation. | | `mpp-spt` | Settles from a Stripe shared payment token | | `x402-exact` | Settles on-chain with an x402 `exact` USDC transfer | The payment rail is pinned when the experiment is created, and an *explicit* `X-Adaptyv-Payment-Method` cannot switch it: a header naming a rail other than the pinned one is rejected with `409` — retry with the pinned rail. Header-less discovery is the deliberate exception: a caller with a machine payment policy is offered every machine rail this deployment serves and commits by sending one rail's credential, which may be a machine rail other than the pinned one (they share a Stripe account, so the pin has already decided everything it decides). Omitting the header is therefore not a way to reach the pinned rail, and a caller with no machine policy falls through to the hosted invoice — which on a crypto-pinned quote is the absent-header `409` in the table above. This is the only endpoint that settles an invoice. The flow is two steps: `POST /quotes/{quote_id}/confirm` issues the invoice and returns a `payment` pointer to this route, then `POST /invoices/{invoice_id}/pay` settles it. Send the first call with the method header and no credential. It answers `402`, and **the challenge is carried in the response headers, not the body** — `PAYMENT-REQUIRED` for `x402-exact`, `WWW-Authenticate` for `mpp-spt`. That challenge is the whole handshake: it carries every parameter needed to produce the credential — for `mpp-spt`, the amount, currency, seller-network id, expiry, and accepted payment-method types to mint the shared payment token against. There is no separate endpoint to fetch them from, and there cannot usefully be one: the credential must echo the challenge it answers, so parameters obtained without taking a `402` cannot be settled here. Both `mpp-spt` and `x402-exact` settle over the API directly with these headers; the MCP server's `pay_invoice` tool is one client of this route, not the only way to reach the rail. Repeat the call with the signed credential to settle — `PAYMENT-SIGNATURE` for `x402-exact`, `Authorization` for `mpp-spt` — and the response is `200` with the paid invoice. Repeating it again is safe: an invoice that is already paid answers `200` with `already_paid: true` and settles nothing. When the settlement can be named, the response carries `settlement_reference`. Treat it as optional even on a settling response. The `payment.methods` array on the confirm response lists the methods this environment accepts; a value outside that list is rejected with `400`. # MCP Server Source: https://docs.adaptyvbio.com/api-reference/mcp-server Drive Adaptyv experiments through Claude Code, Claude Desktop, or any MCP-aware client using natural language. The Cloud Lab MCP is a hosted Model Context Protocol server that gives your agent access to the power of the [Adaptyv API](/api-reference/api-introduction). Point an MCP-aware client at it - Claude Code, Claude Desktop, Cursor, your own agent - and the same things you would do with `curl` against `devs.adaptyvbio.com` become things you can ask for in plain English: list experiments, fetch results, quote a screen, confirm a quote. The agent picks the right tool, fills in the parameters, and shows you the response. A simulated MCP-aware client: the user asks the Cloud Lab MCP for their latest experiments; the agent calls list_experiments, then flags two that are awaiting the user's action — one in Draft, one with a quote sent. ## Why use it You already have the REST API, which is great for fully automated pipelines. But you probably also have interactive workflows or ad-hoc questions. The MCP is perfect for these, when you do not want to compose API queries for a one-off question. Listing the five most recent experiments, pulling the kinetics for a specific run, comparing two cost estimates - these are short, exploratory tasks that benefit from an agent doing the wiring. You stay in your editor or chat client; the agent handles the HTTP plumbing. Pairing the API with reasoning is the other concrete win. Agents are great at using `curl`, but not every agentic environment will give you access to the CLI and the ability to pass the auth token. With the hosted MCP, every MCP-enabled agent can fetch results and then explain whether a `KD` looks tight for your target class, compare a new screen against historical baselines, or sanity-check a quote before you confirm it. You get retrieval and analysis in the same turn, against the same data. We also have plans to enrich the MCP with [interactive MCP apps](https://modelcontextprotocol.io/extensions/apps/overview) and other MCP-specific features, so monitor this page for updates. ## How it fits together The hosted endpoint is `https://mcp.adaptyvbio.com/mcp/`. Every Adaptyv REST endpoint shows up as an MCP tool with the same parameters and the same authorization scopes. | Environment | MCP endpoint | Adaptyv API it fronts | | - | - | - | | Production | `https://mcp.adaptyvbio.com/mcp/` | `https://devs.adaptyvbio.com/api/v1` | | Testing (sandbox) | `https://mcp.testing.adaptyvbio.com/mcp/` | `https://devs.testing.adaptyvbio.com/api/v1` | Most users only need production. The testing sandbox is a separate environment with its own accounts and tokens from the [testing portal](https://foundry.testing.adaptyvbio.com) — handy for trying calls that create or change data without touching real experiments. Keep the trailing slash on the endpoint URL (`/mcp/`). It is the server's canonical OAuth resource identifier: a client that registers the URL without it can fail OAuth discovery with a "protected resource does not match" error, even though plain (token-header) tool calls would still work. Cloud Lab MCP request flow: an MCP-aware client calls the hosted MCP, which forwards to the Adaptyv public API; the API decides what to do and may schedule work in the Adaptyv lab. This means that (for now) whatever you can do with the API, you can do with the MCP, and vice versa. Check out the [API reference](/api-reference/api-introduction) to see a list of endpoints (or ask your agent to figure it out for you). ## Sample queries The examples below show the questions asked to an agent and the equivalent `curl` query an MCP call maps to. All queries presume the following environment variables to be set: ```sh theme={null} export FOUNDRY_API_URL="https://devs.adaptyvbio.com/api/v1" export FOUNDRY_API_TOKEN="" ``` *** **"List the latest five experiments and tell me which ones are awaiting my action."** The agent calls `list_experiments`, reads each entry's `status`, and flags the ones at `Draft` or `QuoteSent`. ```sh theme={null} curl -G "$FOUNDRY_API_URL/experiments" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ --data-urlencode "sort=desc(created_at)" \ --data-urlencode "limit=5" \ | jq '.items[] | select(.status | IN("Draft", "QuoteSent")) | {code, name, status}' ``` *** **"Show me the binding kinetics for experiment ABC-001-042 and tell me whether the K\_D looks tight enough for a follow-up screen."** `get_experiment` resolves the code, `get_results` pulls the kinetic constants, and the agent compares K\_D against typical cutoffs for that target class. ```sh theme={null} curl "$FOUNDRY_API_URL/experiments/ABC-001-042/results" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" # Then read kinetic constants out of the response yourself # and look up typical K_D cutoffs for the target. ``` *** **"Quote a screening assay against the EGFR target from the catalog, for these three sequences."** The agent searches the catalog, picks a self-service target, then runs `cost_estimate` and returns a USD-cents breakdown. ```sh theme={null} TARGET_ID=$(curl -sG "$FOUNDRY_API_URL/targets" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ --data-urlencode "search=EGFR" \ --data-urlencode "selfservice_only=true" \ --data-urlencode "limit=1" \ | jq -r '.items[0].id') curl -X POST "$FOUNDRY_API_URL/experiments/cost-estimate" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "experiment_spec": { "experiment_type": "screening", "method": "bli", "target_id": "'"$TARGET_ID"'", "sequences": { "s1": "EVQLVESGGGLVQPGG...", "s2": "QVQLVQSGAEVKKPGA...", "s3": "DIQMTQSPSSLSASVG..." } } }' ``` *** **"Find any experiment from the last quarter where one of the candidates beat 50nM affinity, and group by target."** The agent paginates `list_results` with a date filter, pulls the affinity values, and groups by `target_id` in one pass. ```sh theme={null} OFFSET=0; ALL="[]" while :; do PAGE=$(curl -sG "$FOUNDRY_API_URL/results" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ --data-urlencode 'filter=and(eq(experiment_type,"affinity"),gte(created_at,""))' \ --data-urlencode "limit=100" \ --data-urlencode "offset=$OFFSET") COUNT=$(jq '.items | length' <<< "$PAGE") ALL=$(jq -s '.[0] + .[1].items' <(echo "$ALL") <(echo "$PAGE")) [ "$COUNT" -lt 100 ] && break OFFSET=$((OFFSET + 100)) done # Then filter ALL for affinity below 50 nM and group by target_id. ``` ## Connect Claude Code Two paths exist: an OAuth flow that uses your Adaptyv portal session, or a long-lived API token of the kind you'd use against the REST API. Both end up with the same downstream authorization; pick whichever fits your context. ### Authentication via OAuth OAuth is the easiest path for interactive use on your own machine. Register the server without an `Authorization` header: ```sh theme={null} claude mcp add \ --scope user \ --transport http \ adaptyv-cloud-lab-mcp \ https://mcp.adaptyvbio.com/mcp/ ``` The first time Claude Code reaches the server, your browser opens and asks you to sign in via the [Adaptyv portal](https://foundry.adaptyvbio.com). Confirm consent on the dialog and Claude Code stores the credential locally for future tool calls. The credential expires with your portal session; you can also revoke it from the portal under Organization → Settings → Tokens. ### Authentication via API tokens For automation, CI, or shared machines, use a long-lived API token instead. Obtain one from the Adaptyv portal as described in [Getting an API token](/api-reference/api-introduction#getting-an-api-token), then register the server with the token in an `Authorization` header: ```sh theme={null} claude mcp add \ --scope user \ --transport http \ adaptyv-cloud-lab-mcp \ https://mcp.adaptyvbio.com/mcp/ \ --header "Authorization: Bearer $FOUNDRY_API_TOKEN" ``` Never paste a Adaptyv token into an LLM chat. Configure it once in your MCP client config — the client forwards the header on every tool call, so the model never sees the token in its context. The sandbox is a separate environment. Sign in at the [testing portal](https://foundry.testing.adaptyvbio.com) for an account and token, then point your client at the testing endpoint with a testing token: ```sh theme={null} claude mcp add \ --scope user \ --transport http \ adaptyv-cloud-lab-mcp-testing \ https://mcp.testing.adaptyvbio.com/mcp/ \ --header "Authorization: Bearer $FOUNDRY_TESTING_TOKEN" ``` For the `curl` examples on this page, set `FOUNDRY_API_URL="https://devs.testing.adaptyvbio.com/api/v1"`. ### Verify `--scope user` writes the registration to `~/.claude.json` and follows you across projects. Use `--scope project` instead if you want the connection to live in the repo's `.mcp.json` and be shared with collaborators (without the token — Claude Code stores secrets per user). ```sh theme={null} claude mcp list ``` Expected output includes the server name and `✓ Connected`, followed by the tool count. If you see `✗ Failed to connect`, the credential is the most likely cause — sign in again (for OAuth) or re-issue your token from the portal and re-register. ## Other MCP clients Any MCP client that speaks streamable HTTP works. The configuration is always two pieces: a URL and either an OAuth flow or a bearer header. Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows) and add: ```json theme={null} { "mcpServers": { "adaptyv-cloud-lab-mcp": { "type": "http", "url": "https://mcp.adaptyvbio.com/mcp/", "headers": { "Authorization": "Bearer YOUR_FOUNDRY_TOKEN_HERE" } } } } ``` Restart Claude Desktop. The Adaptyv tools appear in the tool picker. Any client that supports MCP over streamable HTTP accepts the same three values: ``` Transport: http (streamable) URL: https://mcp.adaptyvbio.com/mcp/ Headers: Authorization: Bearer ``` Consult your client's documentation for where to paste them. ## Where to next The full REST API the MCP wraps — resource groups, status values, filter syntax, webhook payloads. First-time orientation to Adaptyv Foundry: experiment types, the project workflow, and how to set up your organization. # Payments Overview Source: https://docs.adaptyvbio.com/api-reference/payments/overview How an order gets paid: confirm the quote to issue an invoice, then settle it through the hosted invoice page, x402, or a Stripe Shared Payment Token. # Payments Overview Every order is paid the same way in outline. You confirm a quote, which finalizes an invoice, and then you settle that invoice. What differs is how the money moves: a person clicking a link on a Stripe-hosted page, an on-chain USDC transfer, or a card charge your agent authorizes in advance. The default. A person pays a Stripe-hosted invoice page. Your agent signs a USDC transfer; a facilitator settles it on-chain. Your agent mints a bounded Stripe token; Stripe charges the card. ## Base URLs | Environment | Base URL | | - | - | | Production | `https://devs.adaptyvbio.com/api/v1` | | Testing (sandbox) | `https://devs.testing.adaptyvbio.com/api/v1` | The sandbox is a separate environment with its own accounts, tokens, and Stripe objects. Every example in this section uses `$FOUNDRY_API_URL`, so either works: ```bash theme={null} export FOUNDRY_API_URL="https://devs.adaptyvbio.com/api/v1" curl "$FOUNDRY_API_URL/invoices?limit=3" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" ``` Every endpoint authenticates with a bearer token, like the rest of the [API](/api-reference/api-introduction). Confirming a quote and settling an invoice need a token whose role grants the `Quote:Update` and `Invoice:Pay` actions: **Member**, **Billing**, or **Admin**. Member is the usual role for an agent, since it also creates experiments; Billing suits someone who only handles quotes and invoices. Viewer has no access to quotes or invoices at all. ## The two steps Confirming a quote never moves money. It finalizes the invoice and hands back a `payment` block telling you where to pay: ```json theme={null} { "id": "qt_1OqLk2...", "status": "accepted", "invoice_id": "in_1OqLk2LkdIwHu7ix6OboRpXl", "payment": { "kind": "machine", "pay_url": "/api/v1/invoices/in_1OqLk2LkdIwHu7ix6OboRpXl/pay", "methods": ["x402-exact", "mpp-spt"] } } ``` `kind` is `hosted_invoice` for the default rail, carrying `hosted_invoice_url` instead. `kind` is `machine` when the invoice settles programmatically, and `methods` lists the rails this environment accepts. `POST /invoices/{invoice_id}/pay` is the only endpoint that settles an invoice. Call it twice: once without a credential to receive the `402` challenge, once with the credential to settle. Repeating the settling call is safe — an invoice that is already paid answers `200` with `already_paid: true` and charges nothing. ## Choosing a rail One header selects the rail on every call: | `X-Adaptyv-Payment-Method` | Rail | Settlement authority | | - | - | - | | *(absent)* or `async_invoice` | [Hosted invoice](/api-reference/payments/pay-hosted-invoice) | Stripe, when the hosted page is paid | | `x402-exact` | [x402 (`exact`)](/api-reference/payments/pay-x402-exact) | Facilitator settles an EIP-3009 transfer on-chain | | `mpp-spt` | [MPP-SPT](/api-reference/payments/pay-mpp-spt) | Stripe redeems a Shared Payment Token | Any other value is rejected with `400`. Note the spelling: `x402-exact`, never `x402`. Both machine rails are server-side only. A browser cannot send the method or credential headers, or read the challenge headers, so drive these flows from a backend or an agent runtime. At experiment creation you can select the rail in the request body instead: ```json theme={null} { "payment": { "method": "x402-exact" } } ``` Send one or the other. If both are present they must agree, or the request is rejected with `400` (`payment_method_selector_conflict`). A token issued with a machine payment policy is challenged **without** the header: `POST /invoices/{id}/pay` answers `402` offering every rail the environment serves, and whichever credential you send back decides the rail. A stock x402 or MPP client can then pay without knowing the method header exists. Ask [support@adaptyvbio.com](mailto:support@adaptyvbio.com) for such a token. ## What the rail pins The rail you choose when you **create the experiment** binds the experiment's quote and invoice — and the Stripe account they live on — for its whole lifetime. What that pin governs is the **explicit** `X-Adaptyv-Payment-Method` header. Three consequences: * **An explicit header cannot switch rails.** A header on `/pay` naming a different machine rail than the pinned one returns `409`: an experiment created as `x402-exact` cannot be settled by asking for `mpp-spt`, or the reverse. Retry with the pinned rail — the `409` names it. * **Header-less discovery is the deliberate exception.** With a machine-payment token and no header you are offered every machine rail this environment serves, and whichever credential you send back is the rail that settles — including a machine rail other than the pinned one. That is safe because every machine rail shares one Stripe account, so the pin has already done its job by the time you choose. Dropping the header is therefore not a way to reach the pinned rail; and without a machine-payment token it drops you onto the hosted invoice instead. * **Crossing between the hosted-invoice rail and a machine rail is rejected**, explicitly or by discovery. A quote created without a machine rail cannot be settled with one, and a machine-rail experiment cannot fall back to the hosted invoice. Both return `409`. Create a fresh experiment instead. ## Naming what settled A settling `200` carries `settlement_reference` when the payment can be named: ```json theme={null} { "type": "stripe_payment_intent", "payment_intent_id": "pi_3Tw3Ah..." } ``` ```json theme={null} { "type": "x402_transaction", "tx_hash": "0xabc123deadbeef" } ``` Both are independently checkable — in the Stripe dashboard and on Base respectively. Treat the field as optional even on a settling response: some settlements have no reference to report. ## Status codes `POST /invoices/{invoice_id}/pay` answers: | Status | Meaning | | - | - | | `200` | Settled, or already paid (`already_paid: true`) | | `402` | Challenge issued, or the credential you sent was rejected | | `400` | Unrecognized rail, or a malformed credential | | `403` | The token does not grant `Invoice:Pay` | | `404` | Invoice not found, or not yours | | `409` | The header names a rail other than the pinned one, a settlement is already in flight, or the session is closed | | `422` | The invoice is not in a payable state | | `501` | This environment does not serve the requested rail | | `502` | The gateway or facilitator refused, failed, or has not finished | Read a `402` from the response headers and retry. A `402` that answers a credential you sent is a rejection, not a new challenge: it carries a JSON `error` body and no challenge header. `409` and `502` each cover several causes, and the cause decides the remedy. Read the JSON `error` to tell them apart. A `409` means one of: * A credential arrived before you took the `402` — retry without one. * The header names a different machine rail than the experiment pinned — retry with the pinned rail, which the error names. * The rail crosses between the hosted-invoice and machine rails — create a fresh experiment. * A settlement is already in flight — poll. If it has not cleared after several polls, contact support with the invoice id. A `502` means one of: * A card was declined. Declines arrive here, not as a `402`. * A charge is still in flight — poll rather than mint a second token. * An upstream outage — retry the request unchanged. # Pay by hosted invoice Source: https://docs.adaptyvbio.com/api-reference/payments/pay-hosted-invoice The default flow: create an experiment, confirm the quote, and pay the Stripe-hosted invoice in a browser. # Pay by hosted invoice This is how most orders are paid. You create an experiment, Adaptyv prices it into a quote, you confirm the quote, and Stripe issues a hosted invoice page for whoever pays your bills. No payment header, no wallet. You need a token whose role grants `Quote:Update` — **Member**, **Billing**, or **Admin**. Creating the experiment additionally needs `Experiment:Create`, which **Member** and **Admin** carry but **Billing** does not. ```mermaid theme={null} sequenceDiagram autonumber participant You participant API participant Stripe participant Payer as Whoever pays your bills You->>API: POST /experiments (no X-Adaptyv-Payment-Method) API-->>You: experiment id Note over API: Adaptyv prices the work You->>API: POST /quotes/{quote_id}/confirm API-->>You: invoice_id + payment.hosted_invoice_url You->>Payer: send hosted_invoice_url Payer->>Stripe: pay on the hosted page Stripe->>API: notify that the invoice is paid You->>API: GET /invoices/{invoice_id} API-->>You: 200 — paid ``` ## Create the experiment Send no `X-Adaptyv-Payment-Method` header. Its absence selects this rail for an ordinary token and pins the experiment to it. If you hold a token issued with a machine payment policy, send `X-Adaptyv-Payment-Method: async_invoice` explicitly to get the hosted invoice. ```bash theme={null} curl -X POST "$FOUNDRY_API_URL/experiments" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ -H "Content-Type: application/json" \ -d @experiment.json ``` ## Read the quote ```bash theme={null} curl "$FOUNDRY_API_URL/quotes/$QUOTE_ID" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" curl -L "$FOUNDRY_API_URL/experiments/$EXPERIMENT_ID/quote/pdf" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" -o quote.pdf ``` ## Confirm the quote Confirming finalizes the invoice. You may attach a purchase-order number, which appears on it. A JSON body is required either way — send `{}` if you have nothing to attach. ```bash theme={null} curl -X POST "$FOUNDRY_API_URL/quotes/$QUOTE_ID/confirm" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{"purchase_order_number": "PO-2026-00142"}' ``` ```json theme={null} { "id": "qt_1OqLk2...", "status": "accepted", "invoice_id": "in_1OqLk2LkdIwHu7ix6OboRpXl", "payment": { "kind": "hosted_invoice", "hosted_invoice_url": "https://invoice.stripe.com/i/acct_1234/test_5678" } } ``` Send `hosted_invoice_url` to whoever pays your bills. They can view the invoice, pay it with any method you have enabled, and download the PDF and receipt — see Stripe's [hosted invoice page](https://docs.stripe.com/invoicing/hosted-invoice-page). Confirming is one-way. A second confirm on the same quote returns `409`. To decline, call `POST /quotes/{quote_id}/reject` first. ## Check that it settled Payment happens on Stripe's page, outside the API: there is no credential to submit and no endpoint that completes it. Stripe notifies the API when the money clears, and the invoice flips from `open` to `paid`. ```bash theme={null} curl "$FOUNDRY_API_URL/invoices/$INVOICE_ID" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" curl -L "$FOUNDRY_API_URL/invoices/$INVOICE_ID/pdf" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" -o invoice.pdf ``` To remove the browser step, have an agent settle the invoice with [x402](/api-reference/payments/pay-x402-exact) or [MPP-SPT](/api-reference/payments/pay-mpp-spt) instead. Both are selected at experiment creation. # Pay with a Shared Payment Token (MPP-SPT) Source: https://docs.adaptyvbio.com/api-reference/payments/pay-mpp-spt Read the challenge, mint a bounded Stripe Shared Payment Token, and settle the invoice as a single card charge. # Pay with a Shared Payment Token (MPP-SPT) This rail settles from a card rather than a crypto balance. Your agent takes a `402` challenge that says what the token must authorize, mints a [Stripe Shared Payment Token](https://docs.stripe.com/agentic-commerce/concepts/shared-payment-tokens) bounded to those values, and hands it back; Stripe redeems it as one card charge. The API never sees the underlying payment method, only the token. Shared Payment Tokens are Stripe's mechanism for [agentic commerce](https://docs.stripe.com/agentic-commerce): a limited-scope credential the buyer issues and the seller redeems, capped by amount, currency, recipient, and expiry. You need a token whose role grants `Invoice:Pay` — **Member**, **Billing**, or **Admin**. Creating the experiment additionally needs `Experiment:Create`, which **Member** and **Admin** carry but **Billing** does not. ```mermaid theme={null} sequenceDiagram autonumber participant You as Your agent participant API participant Stripe You->>API: POST /experiments (X-Adaptyv-Payment-Method: mpp-spt) API-->>You: experiment id Note over API: Adaptyv prices the work You->>API: POST /quotes/{quote_id}/confirm API-->>You: invoice_id + payment.pay_url You->>API: POST /invoices/{invoice_id}/pay (no credential) API-->>You: 402 + WWW-Authenticate header You->>Stripe: mint an SPT bounded to the challenge values Stripe-->>You: spt_… You->>API: POST /invoices/{invoice_id}/pay (Authorization: Payment …) API->>Stripe: charge the SPT Stripe-->>API: pi_… succeeded API-->>You: 200 — paid + settlement_reference (payment_intent_id) ``` ## Read the challenge Create the experiment with `X-Adaptyv-Payment-Method: mpp-spt` to pin the rail, confirm the quote, then call `/pay` with the method header and no credential. This call commits to nothing — it opens the payment session and answers `402` with the challenge in the `WWW-Authenticate` response header: ```bash theme={null} curl -i -X POST "$FOUNDRY_API_URL/invoices/$INVOICE_ID/pay" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ -H "X-Adaptyv-Payment-Method: mpp-spt" ``` ```http theme={null} WWW-Authenticate: Payment id="dK9sQ2p…", realm="adaptyv-foundry", method="stripe", intent="charge", request="eyJhbW91bnQiOiIxMjUwMCIsImN…", expires="2026-05-27T12:05:00+00:00", description="Experiment 1f0b2c3d payment" ``` That arrives as one line; it is wrapped here to fit. `id` is opaque — echo it back verbatim. It is not a Stripe object id. The challenge is the whole handshake. `request` is base64url-encoded JSON carrying everything the token must encode: ```json theme={null} { "amount": "12500", "currency": "usd", "description": "Experiment 1f0b2c3d payment", "externalId": "in_1OqLk2LkdIwHu7ix6OboRpXl", "methodDetails": { "networkId": "profile_…", "paymentMethodTypes": ["card", "link"] } } ``` `amount` is in the currency's minor unit — cents for `usd`, so `"12500"` is \$125.00. Keep the whole challenge, not just the decoded values — your credential echoes it back, as [below](#retry-with-the-credential). This is also why no endpoint hands you these values without a `402`: the API settles against the challenge it stored when it opened the session, so parameters obtained any other way would echo a challenge no session is holding. A credential sent before a challenge is answered with `409`. `501` means this environment does not serve the rail at all; `422` means the invoice is not in a payable state. The challenge arrives under the standard `WWW-Authenticate` name, so a stock MPP client reads it without special handling. ## Mint the SPT Mint the SPT against `methodDetails.networkId`, denominated in `currency`, capped at `amount`, and expiring no earlier than the challenge's `expires` — roughly five minutes out. Bound the token to those four values. The API re-checks them against the challenge before handing the token to Stripe, and Stripe refuses a token that authorizes less than the amount due, targets another recipient, uses another currency, or has expired. Bound looser and you are carrying risk for nothing. The challenge is valid for five minutes. Mint and settle inside that window. A credential echoing an expired challenge is refused with `409`; call `/pay` again without a credential to take a fresh challenge on the same invoice. ## Retry with the credential The credential is base64url without padding, wrapping the token and an echo of the challenge: ```json theme={null} { "challenge": { "id": "…", "realm": "…", "method": "…", "intent": "…", "request": "…", "expires": "…" }, "payload": { "spt": "spt_…", "externalId": "…" } } ``` Copy every `challenge` value verbatim from the `WWW-Authenticate` parameters, `request` included as the raw string you received. The API compares your echo against the challenge it issued, so a re-encoded `request` is refused even though it decodes to the same JSON. Send the credential in the `Authorization` header under the `Payment` scheme, and move your API token to `X-Adaptyv-Api-Key`: ```bash theme={null} curl -i -X POST "$FOUNDRY_API_URL/invoices/$INVOICE_ID/pay" \ -H "X-Adaptyv-Api-Key: $FOUNDRY_API_TOKEN" \ -H "Authorization: Payment $SPT_CREDENTIAL" \ -H "X-Adaptyv-Payment-Method: mpp-spt" ``` Do not send `Authorization` twice. Only the first value is read, so a bearer token there hides the payment credential behind it and you are re-challenged forever with nothing to explain why. The two credentials need two headers. Send this request with a raw HTTP client rather than a generated SDK. The API validates the credential and charges the token. No charge exists until this request. ```json theme={null} { "id": "in_1OqLk2LkdIwHu7ix6OboRpXl", "status": "paid", "already_paid": false, "settlement_reference": { "type": "stripe_payment_intent", "payment_intent_id": "pi_3Tw3Ah..." } } ``` If the charge succeeds but the response never reaches you, repeat the call. The API returns the charge it already made rather than making a second one. # Pay with x402 (exact) Source: https://docs.adaptyvbio.com/api-reference/payments/pay-x402-exact Sign an EIP-3009 transferWithAuthorization, send it in the PAYMENT-SIGNATURE header, and let the facilitator verify and settle the USDC transfer on-chain. # Pay with x402 (`exact`) Your agent signs an [EIP-3009](https://eips.ethereum.org/EIPS/eip-3009) `transferWithAuthorization` over [EIP-712](https://eips.ethereum.org/EIPS/eip-712) typed data and sends the signature. The API recovers the signer, then asks a **facilitator** — Coinbase CDP — to verify it and broadcast the transfer. The signature is the payment: there is no deposit address and no card. Coinbase's [x402 overview](https://docs.cdp.coinbase.com/x402/welcome) and [quickstart for buyers](https://docs.cdp.coinbase.com/x402/quickstart-for-buyers) cover the client side, including the `@x402/fetch` and `@x402/axios` wrappers and the Go and Python clients that handle the `402` retry for you. You need a token whose role grants `Invoice:Pay` — **Member**, **Billing**, or **Admin** — an EOA whose key your agent controls, and that EOA funded with USDC on the network the challenge names. Creating the experiment additionally needs `Experiment:Create`, which **Member** and **Admin** carry but **Billing** does not. ```mermaid theme={null} sequenceDiagram autonumber participant You as Your agent participant API participant CDP as CDP facilitator participant Chain as Base You->>API: POST /experiments (X-Adaptyv-Payment-Method: x402-exact) API-->>You: experiment id Note over API: Adaptyv prices the work You->>API: POST /quotes/{quote_id}/confirm API-->>You: invoice_id + payment.pay_url You->>API: POST /invoices/{invoice_id}/pay (no credential) API-->>You: 402 + PAYMENT-REQUIRED header Note over You: sign the EIP-3009 authorization You->>API: POST /invoices/{invoice_id}/pay (PAYMENT-SIGNATURE: …) API->>CDP: verify the signature CDP-->>API: verified API->>CDP: settle the transfer CDP->>Chain: broadcast the transfer Chain-->>CDP: tx_hash CDP-->>API: receipt API-->>You: 200 — paid + settlement_reference (tx_hash) ``` ## Create the experiment ```bash theme={null} curl -X POST "$FOUNDRY_API_URL/experiments" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ -H "X-Adaptyv-Payment-Method: x402-exact" \ -H "Content-Type: application/json" \ -d @experiment.json ``` Confirm the quote as usual. The response carries `payment.pay_url` — the invoice route you settle at. ## Read the challenge Call `/pay` with the method header and no credential: ```bash theme={null} curl -i -X POST "$FOUNDRY_API_URL/invoices/$INVOICE_ID/pay" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ -H "X-Adaptyv-Payment-Method: x402-exact" ``` The challenge is in the `PAYMENT-REQUIRED` response header, base64-encoded, not in the body. Decode it: ```json theme={null} { "x402Version": 2, "resource": { "url": "https://devs.adaptyvbio.com/api/v1/invoices/in_1OqLk2…/pay", "description": "Sign an EIP-3009 transferWithAuthorization of exactly …", "mimeType": "application/json" }, "accepts": [ { "scheme": "exact", "network": "eip155:8453", "amount": "125000000", "payTo": "0x…merchant-eoa…", "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", "maxTimeoutSeconds": 300, "extra": { "name": "USD Coin", "version": "2", "assetTransferMethod": "eip3009" } } ] } ``` `payTo` is the merchant EOA, not a deposit address. `asset` is the raw ERC-20 contract address, and `network` its CAIP-2 chain id — read both from the challenge rather than hardcoding them. `extra` carries the token's EIP-712 domain, `name` and `version`. `resource.url` names the route you retry against, which is the `/pay` route you just called. ## Sign the authorization Build the EIP-712 typed-data message for the token's `transferWithAuthorization`: * `from` — your EOA. * `to` — `payTo` from the challenge. * `value` — the challenge's `amount` verbatim. It is already in the token's base units, so do not rescale it; the signed value must equal it exactly. * `nonce` — a fresh 32-byte random value **you** generate. It is your own on-chain replay token; the challenge does not issue one. * `validAfter`, `validBefore` — a window **you** choose. `validAfter` must be at or before now, and `validBefore` no later than `maxTimeoutSeconds` (300 seconds) from now. The EIP-712 domain must match the token contract exactly: `name` and `version` from the challenge's `extra`, the chain id, and the challenge's `asset` as the verifying contract. The API recovers the signer over the same hash, so a domain that differs in any field recovers a different address and the payment is refused. Read `name` and `version` from the challenge rather than assuming them. USDC's EIP-712 domain is not the same string on every chain, and a wrong domain fails as an authorization error with nothing pointing at the cause. ## Retry with the signature Base64-encode the signed payload as JSON and send it in the `PAYMENT-SIGNATURE` header: ```bash theme={null} curl -i -X POST "$FOUNDRY_API_URL/invoices/$INVOICE_ID/pay" \ -H "Authorization: Bearer $FOUNDRY_API_TOKEN" \ -H "X-Adaptyv-Payment-Method: x402-exact" \ -H "PAYMENT-SIGNATURE: $SIGNED_PAYLOAD_B64" ``` The API recovers the signer, checks the recipient, amount, and deadline, then asks the facilitator to verify. The facilitator is authoritative on balance and on whether the nonce is already spent. On success it broadcasts the transfer, and the transaction hash comes back on the `200`: ```json theme={null} { "id": "in_1OqLk2LkdIwHu7ix6OboRpXl", "status": "paid", "already_paid": false, "settlement_reference": { "type": "x402_transaction", "tx_hash": "0xabc123deadbeef" } } ``` A `not_yet_settled` verdict re-emits the same `402`. That is not a rejection — retry with the **same** signature. Re-signing burns the nonce for nothing. Every other `402` after you send a signature is final: a recovered signer that does not match, a wrong amount or recipient, an expired `validBefore`, or a spent nonce. Resending the same signature will not clear any of them — fix the cause and sign a corrected authorization, with a fresh nonce. The challenge does not change, so reading it again returns the same terms. This rail has no settlement recovery. If a settling call dies before you read its response, check the invoice status and your EOA on Base before signing anything else — a transfer that reached the chain but was never recorded looks exactly like a rejection, and signing again with a fresh nonce pays twice. # Accept quote Source: https://docs.adaptyvbio.com/api-reference/quotes/accept-quote https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/quotes/{quote_id}/confirm Finalizes and accepts a Stripe quote, creating the (open, unpaid) invoice and advancing the linked experiment to `WaitingForMaterials`. Optionally attach a purchase order number for your records. A JSON body is required. Every field of `ConfirmQuoteRequest` is optional, so a caller with no purchase-order number and no notes sends `{}` — the refusal says so if they forget (BUG-0059). This endpoint is **categorically non-settling**: it never settles a payment and never emits a payment `402`. The `200` response carries the finalized invoice plus a HATEOAS `payment` pointer telling you where and how to pay — the Stripe-hosted page for an async-invoice quote, or `POST /invoices/{invoice_id}/pay` for a machine rail (x402-exact / mpp-spt), where the `402` challenge is answered. The quote must be in a confirmable state ("Waiting for confirmation" or "Quote sent") and must not already have an invoice. Expired or otherwise non-confirmable quotes return 409. # Get quote Source: https://docs.adaptyvbio.com/api-reference/quotes/get-quote https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/quotes/{quote_id} Returns the full quote document with itemized pricing, totals, expiration, and status, combined with experiment metadata (org name, notes). # List quotes Source: https://docs.adaptyvbio.com/api-reference/quotes/list-quotes https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/quotes Returns every quote recorded for the caller's organization. Use this list to monitor pending proposals, track which quotes have already been accepted or expired, and review pricing history before moving to the detail or acceptance endpoints. # Reject quote Source: https://docs.adaptyvbio.com/api-reference/quotes/reject-quote https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/quotes/{quote_id}/reject Cancels the quote on Stripe and records the rejection reason and optional feedback in the database. The linked experiment reverts to `Draft` so it can be modified and re-submitted. # Get result Source: https://docs.adaptyvbio.com/api-reference/results/get-result https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/results/{result_id} Returns a single result with its full `summary`: mean kinetics and the per-replicate measurements for an affinity result, or the per-sample melting readouts for a thermostability result. The `data_package_url` field links to the raw data package, the same one available in the Foundry portal. # List results Source: https://docs.adaptyvbio.com/api-reference/results/list-results https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/results Lists completed analysis results, sorted by creation date (newest first). Results appear when an experiment's `results_status` field reaches `Partial` or `All`. Paginate with `limit` (default 50) and `offset`; the response includes `total` for page calculation. Each result includes its full `summary` (kinetics for BLI, readouts for thermostability) and `metadata`, matching the detail endpoint shape. Supports filtering on result fields; invalid filter fields return 400. # Add sequences to experiment Source: https://docs.adaptyvbio.com/api-reference/sequences/add-sequences-to-experiment https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/sequences Appends sequences to a draft experiment identified by its human-readable code (e.g., "PROJ-001"). The experiment must be in Draft status; confirmed or later-stage experiments cannot accept new sequences. Create a new experiment to submit additional sequences if the original has progressed past draft. # Get sequence Source: https://docs.adaptyvbio.com/api-reference/sequences/get-sequence https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/sequences/{sequence_id} Returns full details for a specific sequence including the complete amino acid string, metadata, and a reference to the containing experiment. # List sequences Source: https://docs.adaptyvbio.com/api-reference/sequences/list-sequences https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/sequences Returns sequences from all experiments the caller has access to. Results are sorted by creation date (newest first). Filter by `experiment_id` to retrieve sequences for a specific experiment, or use `search` to match against sequence names or amino acid content. # Get custom target request Source: https://docs.adaptyvbio.com/api-reference/targets/get-custom-target-request https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/targets/request-custom/{request_id} Retrieves full details of a custom target request, including sequence data, PDB information, and metadata. Returns 404 if the request doesn't exist or belongs to a different organization. # Get target Source: https://docs.adaptyvbio.com/api-reference/targets/get-target https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/targets/{target_id} Returns the catalog record for a single target by UUID. Retrieves target details including vendor name, catalog number, and `pricing` where self-service pricing is available. **Pricing:** Targets with `pricing` support instant cost estimation via `/experiments/cost-estimate`. Targets without this field require a custom quote — contact support for pricing on these targets. Returns 404 if the target doesn't exist. # List custom target requests Source: https://docs.adaptyvbio.com/api-reference/targets/list-custom-target-requests https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/targets/request-custom Returns custom target requests for your organization, sorted by creation date (newest first). Supports filtering by status using the `filter` parameter (e.g. `filter=eq(status,pending_review)`) and pagination. # List targets Source: https://docs.adaptyvbio.com/api-reference/targets/list-targets https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/targets Lists validated antigens available for experiments. Each entry includes vendor and catalog identifiers, plus `pricing` where self-service pricing is available. **Pricing:** Targets with `pricing` support instant cost estimation via `/experiments/cost-estimate`. Targets without this field require a custom quote — contact support for pricing on these targets. Use `selfservice_only=true` to filter to only targets with pricing configured. Search by product name with `search` (case-insensitive substring). Filter and sort by `name`, `vendor_name`, `catalog_number`, or `purity` via the `filter` and `sort` parameters (e.g. `?filter=gte(purity,90)&sort=-name`). Paginate with `limit` (default 50, max 100) and `offset` (default 0); the response includes `total` for computing remaining pages. Pass the returned `id` as `experiment_spec.target_id` when creating experiments. # Submit custom target request Source: https://docs.adaptyvbio.com/api-reference/targets/submit-custom-target-request https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/targets/request-custom Submit a new custom target (antigen) for staff review. At least one of `sequence` or `pdb_id` must be provided. The `product_id` must be unique within your organization. New requests are created with `pending_review` status. Staff will review and approve or reject the request. Approved targets receive a `material_id` linking them to the catalog. # Attenuate token Source: https://docs.adaptyvbio.com/api-reference/tokens/attenuate-token https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/tokens/attenuate Add restrictions to an existing token without needing the private key. Attenuation is a Biscuit cryptographic feature that allows anyone holding a token to add restriction blocks. The resulting token can only do a subset of what the original token could do—restrictions cannot be removed. # Security Model This endpoint requires the `token:read` capability. 1. **Cryptographic guarantee**: Attenuation can only *reduce* permissions, never expand them. The Biscuit format ensures restriction blocks are append-only and cannot be removed without invalidating the signature. 2. **Self-service by design**: Users can only attenuate tokens they already possess. If you have a token, you can create a weaker version of it—this is analogous to being able to share read-only access to something you own. 3. **No privilege escalation**: The attenuated token inherits all existing restrictions from the source token, plus any new ones added. A read-only token cannot be attenuated into a read-write token. # Use Cases - Create a read-only version of your token for delegation - Restrict a token to specific resources or actions - Generate time-limited tokens for external services - Scope a broad token down to a single organization or project # Timezone All timestamps use UTC in ISO 8601 / RFC 3339 format. # Further Reading For the cryptographic properties of token attenuation, see the [Biscuit documentation](https://doc.biscuitsec.org/). # List tokens Source: https://docs.adaptyvbio.com/api-reference/tokens/list-tokens https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/tokens Returns a flat, paginated list of all tokens (root and attenuated) the caller owns. Each item carries lineage fields (`parent_token_id`, `root_token_id`, `kind`) so callers can reconstruct the derivation tree. Admins with global scope see all tokens across all users. # Revoke the calling token and its entire lineage Source: https://docs.adaptyvbio.com/api-reference/tokens/revoke-the-calling-token-and-its-entire-lineage https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/tokens/revoke Revokes the root token used to authenticate this request and all of its attenuated descendants, making the entire token family invalid for future API calls. **Idempotent**: If the token family is already revoked, returns the original revocation timestamp and `children_revoked: 0`. **Requires token:revoke capability.** # List updates Source: https://docs.adaptyvbio.com/api-reference/updates/list-updates https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/updates Returns the experiment update feed, newest first: status changes, progress markers, and completion events. Use `limit` and `offset` query parameters for pagination. Filter by experiment or type using the `filter` parameter, e.g. `filter=eq(experiment_id,)` or `filter=in(experiment_id,uuid1,uuid2)` or `filter=eq(type,status_change)`. # List the organization's webhook registrations. Source: https://docs.adaptyvbio.com/api-reference/webhooks/list-the-organizations-webhook-registrations https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/webhooks # Modify a webhook registration, including rotating or clearing its secret. Source: https://docs.adaptyvbio.com/api-reference/webhooks/modify-a-webhook-registration-including-rotating-or-clearing-its-secret https://devs.adaptyvbio.com/api/v1/openapi.json patch /api/v1/webhooks/{webhook_id} # Register a webhook for the organization. Source: https://docs.adaptyvbio.com/api-reference/webhooks/register-a-webhook-for-the-organization https://devs.adaptyvbio.com/api/v1/openapi.json post /api/v1/webhooks # Remove a webhook registration. Source: https://docs.adaptyvbio.com/api-reference/webhooks/remove-a-webhook-registration https://devs.adaptyvbio.com/api/v1/openapi.json delete /api/v1/webhooks/{webhook_id} # Who am I Source: https://docs.adaptyvbio.com/api-reference/whoami/who-am-i https://devs.adaptyvbio.com/api/v1/openapi.json get /api/v1/whoami Identify yourself from your API token. Returns the organizations your token can access — with the organization you are currently acting as marked `active: true` — along with your user id, the permissions your token grants, and when the token expires. This is a safe, read-only call: it does not create or change anything. Use it to look up your organization's name and id (needed by other endpoints) or to check what your token is allowed to do. # Changelog Source: https://docs.adaptyvbio.com/changelog/changelog Track updates and changes to Adaptyv Bio's documentation and services ## 2025-08-01 **Changelog coming soon** We're preparing a comprehensive changelog to track all updates and improvements. Check back soon! # Cross-Lab Validation Source: https://docs.adaptyvbio.com/docs/data-quality/cross-lab-validation Our binding calls run against an independent lab's on the same designs, with the raw traces from both labs public. In August 2026 Anthropic had 1,440 Claude-designed miniproteins synthesized and tested independently by two labs, Adaptyv Bio and Twist Bioscience, neither able to see the other's data. The two labs ran genuinely different formats: cell-free monovalent designs on single-cycle SPR here, HEK293-expressed Fc fusions on a high-throughput SPR array there. On the 1,235 designs measured at both labs, our binder and non-binder calls agreed with Twist's **89% of the time**, with a Cohen's κ of 0.71. The raw sensorgrams, fits and per-design labels from both labs are public under CC BY 4.0, so the comparison can be redone rather than taken on trust. The full report, 18 August 2026, including the assay conditions at both labs and the adjudication rule used where they disagreed. Raw traces, fits and per-design labels from both labs, plus the computational models for all 1,440 designs. Agreement here is on binder versus non-binder, not on KD. The two formats differ in valency, so the affinity values are not directly comparable, and the report does not claim otherwise. ## Related pages * [Binding](/docs/experiment-types/binding) * [Binding Data Package](/docs/experiment-setup/binding-data-package), the raw traces and fits you get from your own runs * [SPR technology overview](/wiki/technologies/SPR) # Binding Data Package Source: https://docs.adaptyvbio.com/docs/experiment-setup/binding-data-package What arrives in your downloadable binding data bundle and how to work with it. When a kinetics experiment is pushed to the portal, we generate a new archive that captures the exact data version customers can download. Download additional raw data button ## Getting Started 1. Download the `package.zip` archive from the Foundry Portal (`Download Data` → `Download additional raw data`). 2. Unzip and open the extracted `package/` directory. 3. Use the sections below as a field guide while browsing. All contents are safe to share publicly and ready for downstream analysis or visual inspection. ## Folder Overview ### `kinetics/` PNG sensorgrams for each sample replicate, named `_.png`. Use these plots for quick visual QC without loading raw data. ### `raw_data/` CSV exports of the instrument readouts, using `__.csv`. Columns: * `t`: time in seconds * `y`: instrument response in nanometers Additional notes: * Values are rounded to three decimals to reduce package size. * Neutralisation controls follow `control__.csv` and share the same schema. ### `fit_data/` Modelled sensorgrams for replicates with approved fits (`t`, `y` columns), matching the `raw_data/` filename convention. Overlay these with the raw traces to reproduce kinetics calculations. ### `aux/` Metadata lives in `replicate_info.csv`: * `name`: OS-safe protein identifier * `replicate`: replicate index * `method`: `BLI` or `SPR` * `MAE`: mean absolute error (two decimals) * `rel_MAE`: MAE normalized by maximum signal * `rmax_estimate`: estimated Rmax value ### `blanks/` (when provided) Background and reference material for the experiment. * `raw_data/` * `_.csv`: blank curves (`t`, `y`) * `read_data.csv`: metadata with `read`, `run`, `concentration_nM`, `filename` * `figures/` * `blank_.png`: visualizations of blank sensorgrams * `run_mapping.csv` * Columns: `name`, `replicate`, `runs` — shows blank runs tied to each replicate. ## Additional Notes * Filenames replace spaces and special characters with underscores for compatibility. * Folder structure is machine-readable and works well with automated pipelines. * Each archive reflects the current data version; redownload after updates to stay in sync. # Creating Experiments Source: https://docs.adaptyvbio.com/docs/experiment-setup/creating-experiments Learn how to create experiments ## User Guide: Creating Experiments in Foundry Portal #### Overview Here's how the experiment creation process works: 1. **Create a draft experiment.** You can refine this draft at any time, with no payment commitment. 2. **Submit for review.** When you’re ready, click the “Move to Review” button. 3. **Receive your quote.** Our team will review your experiment and prepare a final quote. 4. **Confirm and start production.** After reviewing the quote, confirm to start the production process. ### 1. Creating a New Draft Experiment #### Initial Setup To begin creating a new experiment, locate the navigation sidebar and click the "New Experiment" button. #### Required Information Foundry Portal new-experiment form showing the required fields **1. Experiment Name** Start by choosing a descriptive name for your experiment. This name will be used throughout the system for tracking and reference purposes, so make it specific enough to identify the experiment's purpose. **2. Assay Type Selection** Select the type of assay you want to perform from the available options. Each assay type has its own pricing structure and specific requirements, including its own minimum order size. You'll find detailed documentation links next to each option to help you understand the differences. **3. Target Configuration** Target configuration step, choosing a catalog target or entering a custom one You have two options for configuring your target: *Using a Catalog Target:* Our database contains pre-validated targets that you can select from. Using a catalog target offers several advantages: * The supplier information is automatically filled in * We’ve worked with this supplier before * Quality control data is available *Creating a Custom Target:* If you're working with a custom target you can’t find in the catalog, you'll need to provide: * The target name (required) * The amino acid sequence (required) * A supplier URL (optional, but recommended) * Any additional notes about special handling or considerations **4. Protein Designs Upload** You can upload your protein designs using one of two methods: *CSV Upload:* When using a CSV file, you'll need to include: * A column for sequence names * A column for amino acid sequences * An optional column for marking controls Our CSV mapping tool will help you match your columns to our required fields, and we'll automatically validate the sequence formats. *FASTA Upload:* If you prefer FASTA format: * The sequence headers will become your sequence names * The sequences will be automatically parsed **5. Selecting Controls** After uploading your sequences, you'll be able to designate certain sequences as controls (if you have a “Control” column in your CSV with boolean values, controls will be selected automatically) Sequence upload step with individual sequences designated as controls **6. Configuration Options** Finally, configure the experimental parameters: * Set the number of replicates (the default is duplicate; triplicate is available as an add-on) * Add any additional notes or special requirements * The estimated price is for your information only and will most likely change after our review. For instance, it does not include the target cost or potential discounts, which will be added to your final quote ### 2. Draft Mode In draft status, you can freely edit your experiment. The system updates price estimates, saves progress without commitment, and provides instant feedback on parameter validity. ### 3. Moving to Review Draft experiment being moved to review in the Foundry Portal When you're ready to proceed with your experiment, the review process begins. **Initiating Review** The review process starts when you click the "Move to Review" button. * Your experiment details will be locked during review * Our team will assess the technical feasibility * A final quote will be prepared * You'll receive notifications about the review progress **During Review** Experiment in review status while the team prepares the quote While your experiment is under review, you'll see a status indicator showing "In Review". During this period: * The experiment details are locked to maintain consistency * You'll receive email updates about the review progress * Our team may reach out with questions or suggestions If you need to make changes during the review period, you can use the "Remove from Review" button to: * Return the experiment to draft status * Make necessary modifications * Resubmit to Review when ready #### After Review: Quote, ETA and Confirmation Quote, results ETA and confirmation step at the end of review After your experiment is approved, you’ll receive a quote and an estimated timeline. *Quote:* A detailed cost breakdown, including discounts, fees, and the total price, will be provided. *Timeline:* You’ll also get a start date and estimated completion date (ETA) for your experiment results. ### 4. Confirming your Experiment When confirming the experiment, you commit to pay the full amount of the quote. The confirmation process is simple but crucial: **Review the Quote:** Access and download the complete quote PDF from the experiment page. **Final Confirmation:** Click “Confirm Experiment,” acknowledge the terms and timeline, and submit your confirmation. #### Post-Confirmation Once confirmed, the process moves forward automatically: • The experiment status updates to “In Production.” • Materials are ordered to begin your experiment. • The experiment appears under “Active Experiments” on your dashboard. **Timeline and Milestones** Here’s what to expect: 1. **Waiting for Materials (5–10 days):** We’ll order the required gene fragments and target. 2. **In Production:** Once all materials arrive at our lab, we’ll begin protein expression and proceed with the steps specific to your selected assay type. 3. **Data Analysis and Validation:** Lab-generated data undergo rigorous processing and quality control (QC) to ensure reliability. If results are unclear, we’ll initiate re-runs as needed. 4. **Done:** Results are delivered via the Foundry Portal, including a full data package with raw lab data. ## Order size The minimum order size depends on the assay. Binding screening and affinity characterization need **24 sequences per target**. Expression, thermostability, enzyme activity and epitope binning need **20 sequences**. The minimum is per target, not per project. Splitting 24 designs across two targets does not meet it: each target needs its own 24 sequences. Two points that come up often: * **The designs do not have to be related.** They can be variants of a single protein, or 24 unrelated sequences. What matters is that they are all being tested against that target. * **Replicates do not count toward the minimum.** The minimum counts distinct sequences, so 10 designs run in duplicate does not meet it. Expression is included with binding assays. It is not a separate line you need to add. See [Binding](/docs/experiment-types/binding) for what each assay covers. If you have fewer designs than the minimum, contact us. We run smaller pilots and benchmarks. ## Controls **You do not need to provide an expression control.** Expression is read out by [split-GFP](/wiki/technologies/split-GFP) against our own internal calibration, so a dedicated expression positive control is not required. **For binding, we do recommend a positive control.** The simplest way is to include your control sequence alongside your designs. During sequence upload there is a field to mark a sequence as a control. Controls count toward your sequence total. An order of 20 sequences with one control contains 19 designs. For newly onboarded targets we do not automatically hold validated positive-control binders. A new target may need a feasibility step before the main experiment. **Plate layout:** to fit controls on the same plate as the designs, the design total needs to be 90 or fewer, or 120 or more. Check that your control is compatible with our platform before you upload it: see [Supported protein formats](/docs/experiment-setup/supported-protein-formats). ## Replicates and concentrations Binding experiments run at multiple target concentrations, in duplicate by default. | Assay | Target concentrations | Replicates | | - | - | - | | Binding screening | 2, plus a zero-concentration blank | Duplicate | | Affinity characterization | 4, plus a zero-concentration blank | Duplicate | The zero-concentration blank is always included, and it is what the other curves are referenced against. Triplicate is available as an add-on. See [our services page](https://www.adaptyvbio.com/services) for cost. The lab may add replicates at its own discretion when a first pass is borderline. This is why some sequences in your results have more replicates than others. # Data Deliverables Source: https://docs.adaptyvbio.com/docs/experiment-setup/data-deliverables What you receive from each experiment type, and how results are delivered. Results and raw data are delivered through the Foundry Portal. Binding screening, affinity characterization and thermostability results are also available via the API. We create an organization for you and can add your teammates, so the whole team can reach the data. ## What you get by experiment type ### Binding * Binder classifications (strong, medium, weak, non-binder) with ranked responses, for screening runs. * Kinetic values (KD, kon, koff) with fit diagnostics, for affinity characterization runs. * A downloadable data package with raw sensorgrams, fitted curves, and metadata, for your own reprocessing. For a full field guide to the binding archive, see [Binding Data Package](/docs/experiment-setup/binding-data-package). ### Expression * An expression call per variant (expressed, low, not detected). * Relative yield, for quick comparison across variants. * QC flags for issues such as insolubility or tag problems. ### Thermostability * Melting temperature (Tm), the primary stability metric. * Onset temperature and transition width, for context on unfolding behavior. * A ranking of variants for developability decisions. ### Enzyme activity * An activity call per variant (active, low, not detected). * Relative rate, normalized for fair comparison across variants. * The assay conditions used: substrate, buffer, temperature, and detection method. ## Controls We run blank and negative controls as part of every assay. These are not attached to the standard download by default, but we are happy to include the control curves on request. Ask when you set up your experiment. ## Notes * Filenames are machine-readable and work well with automated pipelines. * Each download reflects the current data version. Redownload after an update to stay in sync. ## Related pages * [Binding Data Package](/docs/experiment-setup/binding-data-package) * [Creating Experiments](/docs/experiment-setup/creating-experiments) * [Frequently Asked Questions](/docs/faq/overview) # Supported Protein Formats Source: https://docs.adaptyvbio.com/docs/experiment-setup/supported-protein-formats We support single-chain binder formats and Fabs, expressed in cell-free E. coli or yeast. We test a wide range of binder formats, from antibody-derived fragments such as VHHs and Fabs to engineered scaffolds, de novo designed proteins, and peptides. All designs are produced in a [cell-free expression system](/wiki/technologies/cell-free-protein-expression), E. coli or yeast, which is excellent for single-chain formats and Fabs. Constructs of roughly 8 to 700 amino acids are supported. We do not produce full bivalent IgGs. The Fc region does not express well in cell-free, so an intact IgG is not a format we can run. If you have IgG sequences, submit them as scFvs and/or Fabs instead: take the VH and VL domains and send those as the constructs you want expressed. ## Format support | Format | Supported | Notes | | - | - | - | | [VHH / nanobody](/wiki/proteins/vhh) | Yes | Single-chain and well suited to cell-free expression. The most common format we run. | | [scFv](/wiki/proteins/scfv) | Yes | Single-chain. Submit the full construct including your linker of choice. | | [Fab](/wiki/proteins/fab) | Yes | Heavy and light chains are supplied as a paired construct. Carries a per-design surcharge. | | [Minibinder / de novo protein](/wiki/proteins/miniproteins) | Yes | Engineered scaffolds and computationally designed binders. | | [Peptide](/wiki/proteins/peptides) | Yes | Run routinely. The shortest design we have measured binding on is 8 amino acids. | | [Full bivalent IgG](/wiki/proteins/igg) | No | The Fc does not express in cell-free. Submit the VH and VL domains as an scFv or a Fab instead. | ## Submitting sequences We do not clone your designs into fixed scaffolds. You submit the full amino acid sequence you want expressed, exactly as you want it made. For a VHH, that means the complete VHH sequence rather than only the CDRs. For a Fab, supply the heavy and light chains as a paired construct so they are expressed together. Every design also receives a standard tag before expression. See [Construct and tag design](/wiki/technologies/construct-tag-design) for what gets appended and where it sits. Keep each construct within the supported range of approximately 8 to 700 amino acids. Sequences outside this range should be discussed with us before you submit your experiment. ## Expression system Designs are expressed cell-free, which is what makes short turnaround times and large design panels possible. Two systems are available: | System | Notes | | - | - | | Cell-free E. coli | The default, and the right choice for most single-chain formats and Fabs. | | Cell-free yeast | Available as an alternative when a design expresses poorly in E. coli. | If you are not sure which system suits your designs, ask us and we will advise before you submit. Mammalian cell line expression (CHO) is in development and not yet available. Contact us for the current status if your program depends on it. ## Cost and format Format does not change the per-sequence rate. The rate is set by the number of designs you submit, not by which format you choose or how long your sequences are. The one exception is Fab, which carries a per-design surcharge on top of the standard rate. For current rates and the Fab surcharge, see the [Adaptyv Bio services page](https://www.adaptyvbio.com/services). How the expression system works and what it means for your constructs. What we can test your binders against, and how to source a custom target. ## FAQ Not as intact IgGs. The Fc does not express well in our cell-free system, so we cannot produce full bivalent IgGs. The route is to express your IgG sequences as [scFvs](/wiki/proteins/scfv) and/or [Fabs](/wiki/proteins/fab) instead. Take the VH and VL domains from your IgG and submit them either as an scFv, with the two joined by a linker of your choice, or as a paired Fab construct. Not yet. Mammalian cell line expression (CHO) is in development. Today all expression runs cell-free, in either E. coli or yeast. Contact us for the current status if mammalian expression is a requirement for your program. The rate is set by the number of designs you submit, not by format or sequence length. Fab is the exception and carries a per-design surcharge. See the [services page](https://www.adaptyvbio.com/services) for current pricing. No. You submit the full sequence you want expressed and we express exactly that, plus the standard tag described in [Construct and tag design](/wiki/technologies/construct-tag-design). # Target Proteins Source: https://docs.adaptyvbio.com/docs/experiment-setup/target-proteins How to get your target into an Adaptyv experiment, and what we need from it. Every binding experiment starts with a target protein. You can pick one from our catalog, ask us to source or express it, or ship us your own. This page covers all three routes, the spec your target has to meet, and which targets need a feasibility check first. ## Choosing a sourcing route | Route | How it works | Best when | | - | - | - | | Catalog target | Pick from [targets.adaptyvbio.com](https://targets.adaptyvbio.com), the targets available through our regular suppliers. | Your target is listed. This is the fastest way to start. | | We source it | We buy the target from a commercial vendor, or express it in house if it is not purchasable. | Your target is not in the catalog. | | You supply it | You ship us purified protein that meets the spec below. | You already have material, or the target is proprietary. | The target reagent cost is passed through to you separately. It is not part of the per-design assay price. See [adaptyvbio.com/services](https://www.adaptyvbio.com/services) for current pricing. ## Catalog targets The catalog lists the targets we can obtain through our regular commercial suppliers. A listing means the protein is readily available to order, not that we have run it before, so picking from the catalog mainly saves sourcing time rather than guaranteeing prior experience with that antigen. Browse the full list at [targets.adaptyvbio.com](https://targets.adaptyvbio.com) before you request a custom target. If we have run your target previously we will say so when we quote, and we will reuse suitable material we already hold. ## Targets we source for you If your target is not in the catalog, tell us the protein, the species and the region or domain you care about, and we will source it. In most cases we buy it from an external commercial vendor, most commonly from Acro Biosystems, Sino Biological, and Kactus Biosciences. If the target is not commercially available, we may be able to express it in house, provided it is compatible with our cell-free expression system. When the target expresses well, turnaround stays within roughly four weeks. In-house production runs as a ladder: A small-scale run to confirm the target expresses at all in our system. This is the go or no-go step. Scale-up, purification and quality control, sized to how much material your experiment needs. Pricing for each step depends on scale, so ask us for a quote or see [adaptyvbio.com/services](https://www.adaptyvbio.com/services). ## Supplying your own target You are welcome to send us your own material. To go straight into an assay, it should be: * At 0.5 mg/mL or higher, ideally. * In a standard buffer such as PBS or HEPES. * Free of carrier protein. No BSA, no gelatin. * Labelled with the concentration of any glycerol or sodium azide it contains, so we can account for it. Around 150 ug is enough for a typical run. Properly lyophilized protein does not need to ship on dry ice, which makes shipping simpler and cheaper. ## Tag requirements Tags on the target matter, because our binders are immobilized through their own tag. Your target must not carry a Twin-Strep tag and must not be biotinylated. We immobilize binders via a Twin-Strep-tag onto a Strep-Tactin surface, so a Twin-Strep-tagged or biotinylated target competes for the same surface chemistry and will interfere with the assay. Fc-tagged targets are fine to run. Be aware that the Fc dimerizes the target, so apparent affinity can be shifted by avidity. Flag an Fc tag when you set the experiment up so the results are interpreted correctly. For background on how tags are used on the binder side, see [Construct and tag design](/wiki/technologies/construct-tag-design). ## Harder targets Soluble targets are the straightforward case. Membrane proteins are possible, but they carry additional challenges, so we usually start with a feasibility test to validate the target before committing to a full campaign. The same applies to targets that need a non-standard presentation format, such as detergents or nanodiscs. Ask us early and we will tell you what the feasibility step looks like for your specific target. Many membrane proteins have soluble extra-cellular domains (ECD), that are much easier to work with than full length membrane proteins. Full-length is worth attempting when the epitope you care about is not in the ECD. We do not run cell-based assays. Our binding assays measure a purified binder against a purified target. Once your target is settled, see [Binding](/docs/experiment-types/binding) for what the assay measures and [Supported protein formats](/docs/experiment-setup/supported-protein-formats) for what we can run on the binder side. ## FAQ No. The target reagent cost is passed through to you separately from the per-design assay price. Current pricing is at [adaptyvbio.com/services](https://www.adaptyvbio.com/services). Yes. We source most non-catalog targets from a commercial vendor, most commonly Acro Biosystems, Sino Biological, or Kactus Biosciences. If the target is not commercially available, we may be able to express it in house, provided it is compatible with our cell-free expression system. You can also supply the protein yourself. Yes, with caveats. Membrane proteins carry additional challenges, so we usually run a feasibility test to validate the target first. If your target has an extracellular domain, running the ECD is substantially easier than the full-length protein and is normally the faster route to data. Send us the construct you have in mind and we will tell you which route makes sense. Around 150 ug is enough for a typical run. If you are supplying the material yourself, send it at 0.5 mg/mL or higher in PBS or HEPES, without carrier protein. # Binding Source: https://docs.adaptyvbio.com/docs/experiment-types/binding Measure whether and how strongly your proteins bind their targets ## Two ways to run binding ### Binding screening (2 concentrations) * **What it is:** Fast triage using two target concentrations to sort variants by binding strength. * **When to use:** Early discovery and library down‑selection. * **Output:** Strong / Medium / Weak / Non‑binder classification with ranked responses. ### Affinity characterization (4+ concentrations) * **What it is:** Multi‑concentration series (typically 5–7) with global fitting for precise KD, kon, and koff. * **Why this works:** Multiple concentrations across orders of magnitude constrain the fit, separating association (kon) and dissociation (koff). This yields reliable KD across a wider range (≈0.1 nM to 10 µM) than single‑point reads. * **When to use:** Lead optimization, benchmarking, and mechanism studies. * **Output:** KD, kon, koff with confidence intervals and fit diagnostics. Confirm expression and yield before binding. Use Tm to pick robust variants. ## Choose the right depth * **Screening**: Maximize throughput and minimize cost to find winners. * **Characterization**: Quantify kinetics to pick and improve the best. ## Related pages * [Expression](/docs/experiment-types/expression) * [Thermostability](/docs/experiment-types/thermostability) * [Enzyme Activity](/docs/experiment-types/enzyme-activity) * [Binding Data Package](/docs/experiment-setup/binding-data-package) * [Cross-Lab Validation](/docs/data-quality/cross-lab-validation) * [BLI technology overview](/wiki/technologies/BLI) * [SPR technology overview](/wiki/technologies/SPR) ## FAQs Our assay loads your constructs onto sensors and measures association/dissociation against a target analyte. If expression is None/Low, signal-to-noise may be insufficient for precise KD. Stronger expression yields cleaner fits. Typically \~0.1 nM to 10 µM. At the extremes (very tight/weak) accuracy drops; we can adjust concentrations and contact times to bias for tight or weak interactions as needed. True: clear binder above controls. False: expresses but at/below control signals. Unknown: no/low expression or marginal signals. Strength buckets: Strong (sub 50 nM), Medium (50 nM–1 µM), Weak (>1 µM). We record time and wavelength shift at 5 Hz and fit 1:1 models; when multiple concentrations are run, we use global fitting across the series. Screening uses 1–2 concentrations to triage binders; uncertainty is higher than multi‑concentration characterization designed for precise KD, kon, koff. Yes. We can run cross‑reactivity and polyspecificity panels (e.g., BVP, BSA/HSA); full‑serum profiling is in development. We screen new targets for NSB and adjust buffers or suppliers. High NSB can lead to negative‑shift curves after reference subtraction. May indicate multi‑step mechanisms or conformational change. Relative rankings remain useful; precise kinetics may require expanded concentration series. Yes. We run neutralization/inhibition and competition formats (IC50, epitope access) on request. Ready to set up a binding experiment? Visit start.adaptyvbio.com/binding. # Enzyme Activity Source: https://docs.adaptyvbio.com/docs/experiment-types/enzyme-activity Quantify catalytic performance with simple, comparable readouts ## What you get * **Activity call:** Active / low / not detected * **Relative rate:** Normalized activity per variant for fair comparison * **Assay conditions:** Substrate, buffer, temperature, and detection method ## Assay formats * **Endpoint assays:** Single time‑point readouts for high throughput * **Kinetic assays:** Time‑course measurements for rate estimation ## When to use * Early triage of designed enzymes to find active scaffolds * Optimization campaigns to compare mutations and conditions High‑throughput single time‑point readouts for large libraries. Time‑course data to estimate rates and compare variants. Ready to set up an enzyme activity assay? Visit start.adaptyvbio.com/enzyme-activity. ## FAQs Endpoint assays maximize throughput on large libraries. Kinetic assays give you a time course to estimate rates. Screen broadly with endpoint reads, then characterize the variants you care about with kinetic assays. Often, yes. If your reaction is not already covered, contact us with the target reaction and a detection idea, and we will scope and quote the assay development. ## Related pages * [Expression](/docs/experiment-types/expression) * [Thermostability](/docs/experiment-types/thermostability) * [Data Deliverables](/docs/experiment-setup/data-deliverables) # Expression Source: https://docs.adaptyvbio.com/docs/experiment-types/expression Test and quantify expression for your designed proteins. ## What you get * **Expression call:** Expressed / low / not detected * **Relative yield:** Comparable signal per variant for quick triage * **QC summary:** Flags for insolubility or tag issues ## How it works We run your sequences through our standardized cell‑free expression workflow and detect expression via tag‑based readouts. Expression is confirmed and quantified with a split‑GFP reporter, and results land in your dashboard and API with clear calls and QC. ## When to use * Before binding or activity campaigns to avoid running non‑expressers * During library exploration to focus on productive designs Upload sequences via the platform or API. We run standardized expression with tag detection. You get expression calls, relative yield, and QC flags. Ready to set up an expression run? Visit start.adaptyvbio.com/expression. ## FAQs We support roughly 50 to 700 amino acids, covering antibody-derived formats, engineered scaffolds, and de novo proteins. Longer constructs cost more to synthesize; very short peptides are usually limited by yield rather than folding. See [Supported Protein Formats](/docs/experiment-setup/supported-protein-formats). Our QA flags anomalies continuously during data generation, and we re-run a sample when a call is not clear-cut rather than reporting an ambiguous result. Yes. Our default runs express only enough material for the assay. When you want protein in hand, see [Expression Scale-Up](/docs/experiment-types/expression-scale-up). ## Related pages * [Binding](/docs/experiment-types/binding) * [Thermostability](/docs/experiment-types/thermostability) * [Expression Scale-Up](/docs/experiment-types/expression-scale-up) * [Data Deliverables](/docs/experiment-setup/data-deliverables) # Expression Scale-Up Source: https://docs.adaptyvbio.com/docs/experiment-types/expression-scale-up Scale up expression of your best designs and receive purified protein. Our standard workflow is sequences in, data out: we express just enough protein to run your assays. When you want physical material in hand, we can **scale up expression of selected designs and ship purified protein back to you**. Scale-up runs on designs we have already expressed, so it follows an [expression](/docs/experiment-types/expression) assay rather than starting from scratch. ## When to use * You have identified top hits from a screening or characterization campaign and want protein for your own downstream work. * You need purified material for assays we do not run in-house. ## How it works Select the designs you want scaled up, typically your best hits from a prior run, so we reuse the DNA and sequences we already have. We express at a larger volume and purify the protein by affinity tag. Every scale-up includes HPLC-SEC and CE-SDS, so you see purity and aggregation state alongside the material. Purified protein is shipped back in a standard buffer, or a format we agree on for your application. ## Scale options Three culture volumes are available, small, mid and large. Yield depends heavily on the protein, so each tier carries an expected range rather than a guaranteed amount. Contact us for current volumes, yield ranges and prices. If you need more material than the large tier delivers, tell us the amount you need and we will scope it. Turnaround depends on the protein and the tier. Contact us at [support@adaptyvbio.com](mailto:support@adaptyvbio.com), or through your experiment, to scope a scale-up run. ## Related pages * [Expression](/docs/experiment-types/expression) * [Data Deliverables](/docs/experiment-setup/data-deliverables) * [Supported Protein Formats](/docs/experiment-setup/supported-protein-formats) # Thermostability Source: https://docs.adaptyvbio.com/docs/experiment-types/thermostability Measure thermal stability (Tm) to de-risk development and formulations ## nanoDSF Technology Our thermostability measurements use **nanoDifferential Scanning Fluorimetry (nanoDSF)**, a label‑free method that tracks intrinsic fluorescence during thermal unfolding. Purified proteins are prepared in standard buffer conditions or customer-specified formulations. Samples are subjected to controlled temperature increases while monitoring fluorescence changes. The midpoint of the unfolding transition (Tm) is determined from the fluorescence data. Curious about the underlying technique? See the wiki: nanoDSF. ## What you get * **Tm (melting temperature):** Primary stability metric * **Onset temperature and transition width:** Context on unfolding behavior * **Clear ranking:** Compare variants for developability decisions ## When to use * Selecting robust variants for storage and handling * Comparing formulations or mutations for stability impact * Pairing with binding or activity to balance function vs stability ## FAQs nanoDSF reads intrinsic fluorescence, which comes from aromatic residues (tryptophan and tyrosine) in the hydrophobic core. Proteins with those residues give a clear unfolding transition. Some de novo miniproteins do not carry enough aromatic content to produce a strong signal, and may show a weak or absent transition. See the [nanoDSF wiki page](/wiki/technologies/nanodsf). Room temperature to 95 degrees Celsius. Yes, and it is the cheaper way to do it. Adding thermostability to designs we have already expressed for a binding run is priced as an add-on, because it reuses the same material. Ask us to quote the combined scope. ## Related pages * [Expression](/docs/experiment-types/expression) * [Binding](/docs/experiment-types/binding) * [Enzyme Activity](/docs/experiment-types/enzyme-activity) * [Data Deliverables](/docs/experiment-setup/data-deliverables) Ready to set up a thermostability assay? Visit start.adaptyvbio.com/thermostability. # Frequently Asked Questions Source: https://docs.adaptyvbio.com/docs/faq/overview Answers to the questions customers ask us most: order size, timelines, targets, formats, and data. These are the questions we are asked most often. For assay-specific detail, see [Binding](/docs/experiment-types/binding), [Expression](/docs/experiment-types/expression), [Thermostability](/docs/experiment-types/thermostability), and [Enzyme Activity](/docs/experiment-types/enzyme-activity). ## Getting started Onboarding is self-serve. Create an account, start a draft experiment, upload your sequences (CSV or FASTA), and you get an instant price estimate. When you are ready, submit for review and our team prepares a final quote before anything is charged. See [Creating Experiments](/docs/experiment-setup/creating-experiments) for the full walkthrough. The minimum order is **20 designs per target**, and the price per design drops as the batch grows. You do not need one. Confidentiality is already part of our standard terms: your sequences, targets and results are treated as your confidential information from the moment you share them, whether or not a separate agreement is in place. If your organization requires a signed NDA or CDA anyway, we are happy to sign one. We can work from our standard template or review yours. Ask us before you start a draft experiment and we will get it in place first. Reach us through the in-app chat or by emailing [support@adaptyvbio.com](mailto:support@adaptyvbio.com). Both routes reach the same team, and we follow up by email. ## Pricing and quotes Pricing is per sequence and drops as batch size goes up. Binding screening and follow-on affinity characterization are priced separately, so you can size the scope to your budget. See our assay-specific pricing calculators at adaptyvbio.com/services. For a firm quote, including target sourcing and any custom setup, start a draft experiment or contact us with your target and what you want to test. * **Replicates.** Duplicate measurement is included in the base price. Triplicate, 4x, and 5x are available as an upgrade. * **Assay resolution.** Binding screening uses two concentrations for a yes/no call. Full affinity characterization uses four concentrations and returns kinetic constants. * **Additional targets.** Cross-testing the same designs against further targets is priced per design, per target. * **Fab format.** Fab constructs carry a per-design surcharge, because they require two chains. No, the target reagent is quoted separately from the assay. Targets listed in our catalog are available through our regular suppliers, so they are quick to source. Custom or complex targets, for example peptide-MHC complexes, come from specialist vendors, and the reagent cost is passed through. If we already hold suitable target material from a prior run, we reuse it rather than charging for it again. Yes. Adding an assay to designs we have already expressed, for example thermostability alongside binding, or affinity characterization after a screen, is priced at a reduced add-on rate, because we reuse the DNA and expressed material. Ask us to quote the combined scope. Three, and they stack with the volume ladder: * **Academic rates**, a flat per-design rate at any volume, on every assay type. * **ProteinBase**, a further discount for publishing your results to ProteinBase. * **BenchBB**, partner rates arranged through BenchBB. The current rates for all three are on the services pages. Tell us which applies when you request a quote. We invoice through **Stripe** once your experiment is confirmed. That covers card payment and bank transfer, and the invoice can be paid by anyone you forward it to. We also work with procurement teams. We can accept a **purchase order**, quote against a PO number, and complete vendor onboarding or supplier registration if your institution requires us set up as an approved vendor first. Tell us early if a PO has to exist before work starts, since that usually sets the timeline. For larger or ongoing programs we offer **prepurchased credits**: commit to a volume of work up front, draw it down across experiments, and take a volume discount on the whole commitment. Contact us to scope the terms. ## Timelines Typical end-to-end turnaround from sequence submission: | Experiment | Turnaround | | - | - | | Expression | 2 to 3 weeks | | Binding | 3 to 4 weeks | | Thermostability | 2 to 3 weeks | A standard binding run breaks down roughly as: experiment preparation days 1 to 7, protein expression days 8 to 9, kinetic measurements days 10 to 15, data review and release days 16 to 21. Turnaround depends on your target and format. A hard-to-source target adds lead time; one available through our regular suppliers usually does not. Yes. Any follow-on run on designs we have already built is faster than the first one, because it reuses the DNA and expressed material we hold rather than re-synthesizing from scratch. That covers characterizing screening hits, adding a second assay such as thermostability, and counter-screening against another target. Sourcing an unfamiliar or custom target, presenting a full-length membrane receptor (for example via nanodiscs or detergents), or troubleshooting a challenging antigen can each add lead time. We flag any expected impact during the review step, before you confirm. ## Targets and sourcing Either works. We can source the target for you from third-party suppliers, or you can ship your own. If you ship it, we need purified, tagged protein in solution, and we will spec the exact amount, concentration, and format for your target. Browse the targets available through our regular suppliers in the target catalog. In most cases, yes. We can source custom targets by name, UniProt ID, or sequence. Complex reagents such as peptide-MHC complexes come from specialist vendors, since we do not express these in-house, with the reagent cost passed through and additional lead time. Tell us your target and we will confirm feasibility. The extracellular domain (ECD) is the fastest and lowest-risk option, and it is what we recommend when it fits your biology. Full-length presentation via nanodiscs or detergents is possible for some targets but is more involved to set up, so it adds assay-development time. We focus on soluble targets and do not support arbitrary membrane proteins, though we can often work with binding domains derived from them. Some antigens show non-specific binding regardless of buffer or platform, and supplier batches vary. Every new target goes through onboarding QC, and when a reagent is problematic we optimize buffers and blocking, or switch suppliers. We recommend validating a new target before you invest in designing against it. ## Protein formats Peptides and miniproteins, nanobodies (VHH), single-chain variable fragments (scFv), antibody fragments (Fab), de novo proteins, and multi-chain constructs. See [Supported Protein Formats](/docs/experiment-setup/supported-protein-formats) for details and handling notes. Full-length IgGs remain challenging in our microbial cell-free system, and the system does not add glycosylation, so Fc-dependent (effector) work is not supported. Fab, scFv, and VHH are well supported. Yes. We run the same designs against additional targets to check specificity, priced per design, per target. See the binding calculator for the current rate. ## Data, ownership, and IP Results and raw data are delivered through the Foundry Portal and the API. We create an organization for you and can add your teammates. For binding, you can download a full data package with raw sensorgrams, fits, and a table of kinetic values for your own reprocessing. See [Data Deliverables](/docs/experiment-setup/data-deliverables). We encourage you to choose your own positive controls, since you know the binders and affinities that matter for your program, and a control you already trust makes the rest of the plate much easier to interpret. If you do not have one, we are happy to research the target and identify suitable positive controls with you. Raise it when you set up the experiment so we can source the material in time. We run blank and negative controls as part of every assay. They are not attached to the standard download by default, but we are happy to include them on request. Ask when you set up your experiment. The data is yours. We ask for a license to use it to improve our internal process models, for example our expression predictor, never for standalone use, and our standard agreement reflects this. Still have a question? Email [support@adaptyvbio.com](mailto:support@adaptyvbio.com) or start a draft experiment at start.adaptyvbio.com. # Introduction Source: https://docs.adaptyvbio.com/docs/getting-started/introduction Adaptyv is a cloud lab that turns protein sequences into reliable experimental data—fast. Adaptyv Bio Platform Overview You design proteins. We generate the data. Upload sequences, and our automated lab runs the assays and delivers clean results in as little as 21 days—through the platform or API. Start with binding assays for clear readouts on target interaction. Thermostability and additional workflows are rolling out to broaden protein characterization. #### Key Features * **Simple and automated:** Upload via UI or API. We run the assays and notify you when results are ready. * **Fast turnaround:** Get data in \~21 days to speed design cycles and decisions. * **Built for AI‑protein design:** API‑native, high‑throughput, and cost‑efficient to refine models and improve designs. * **Scales with you:** From tens to thousands of designs, the platform adapts to your campaign size. * **Reliable data:** Standardized methods and strict QC deliver accurate, reproducible results. ## Quick Navigation Explore binding, expression, thermostability, and enzyme activity. Set up your first experiment and navigate the platform. See the technologies powering our automated lab workflows. Integrate with our API to automate your workflow. # Project Workflow Source: https://docs.adaptyvbio.com/docs/getting-started/project-workflow End-to-end workflow from configuration to data delivery The configurator lets you define experiment type, protein variants and targets, and any custom requirements (concentrations, controls, replicates). Submission is reviewed for feasibility and fit to platform capabilities. We prepare a project plan with timelines and deliverables. We share adjustments or recommendations for approval. Prepare materials and reagents to ensure consistent downstream execution. DNA synthesis and optimization for our expression system. Cell‑free protein expression of variants. Target sourcing or selection from curated antigen library. Buffer and reagent preparation for binding/stability assays. Run selected workflows (e.g., binding, thermostability) and capture results. Execute assays with appropriate replicates and controls. BLI for binding workflows; label‑free, real‑time readouts. Continuous QA to flag and investigate anomalies. Process and validate results, then deliver in the portal and via API. Fit kinetics (kon, koff, KD) or categorize screening results. Cross‑check against controls and replicates. Provide report with raw data, processed outputs, and notes. Access data and status in the Foundry Portal. # Reading Binding Characterization Results Source: https://docs.adaptyvbio.com/guides/binding-characterization How the binding assay works, how to read a sensorgram, interpret kon, koff, and KD, judge fit quality, and recognize the common curve shapes in your characterization data. A binding experiment answers three questions about every design you send us: **does it bind** the target, **how tightly**, and **how fast it comes off**. A characterization run resolves each interaction into three numbers (`kon`, `koff`, and `KD`) from a family of sensorgrams measured across a concentration series. This guide is the field manual for that output: how the assay produces the curve, what the curve is telling you, and how much to trust the fitted numbers. It sits alongside the [Binding experiment overview](/docs/experiment-types/binding) and the [Binding Data Package](/docs/experiment-setup/binding-data-package) reference, which documents every file in your download. ## How the assay works We measure binding with **biolayer interferometry (BLI)** on a Gator Bio Pro, and **surface plasmon resonance (SPR)** on a Carterra LSA XT. Both are **label-free** (nothing is attached to the target to make it visible) and both produce the same readout. We pick the platform that fits the campaign, leaning on SPR as the higher-throughput option for larger sample sets and BLI for smaller ones. BLI binding assay workflow across four phases: baseline; loading, where a Twin-Strep-tagged binder is captured on the Strep-Tactin surface; association, where target binds; and dissociation. A sensorgram below tracks binding over time, with high, medium, and low target-concentration traces that share one baseline and loading level and diverge only during association. We express each design with a two domain C-terminal tag: a **split-GFP fragment** (for expression quantification), followed by a **Twin-Strep-Tag** that anchors it to the biosensor surface facing outward. The full C-terminal tag is `RDHMVLHEYVNAAGITGGGSGGGSGGSAWSHPQFEKGGGSGGGSGGSAWSHPQFEK`, and your protein is the **ligand**. The sensor is exposed to the target protein (the **analyte**) at known concentrations. If your design recognizes the target, the two associate at the surface. Bound target adds mass at the surface, which shifts the optical signal. We record that shift continuously, with no endpoint and no wash-and-read. Switching exposure to just the buffer solution lets bound target dissociate. The climb and the decay together form the binding curve. ## Anatomy of a sensorgram A sensorgram plots **response** (mass bound at the sensor surface, in nm for BLI or RU for SPR) against **time**. One characterization run overlays several curves, one per target concentration, fitted together as a single family. Annotated sensorgram with three phases: a flat baseline, an association phase where four target concentrations plus a zero-concentration blank rise to concentration-dependent plateaus, and a dissociation phase where every curve decays at the same rate without crossing. The kon and koff phases are labelled. Read each curve left to right in four phases: 1. **Baseline.** Sensor in buffer, no target. This is your zero. 2. **Association.** Target ("analyte") is flowing on. Response climbs as target binds your surface-anchored protein ("ligand"). Higher concentrations climb **faster** and toward a **higher** plateau. 3. **Approach to steady state.** The climb curves over as binding and unbinding reach balance. Whether a curve actually reaches its plateau depends on concentration, `kon`, and how long the injection runs. 4. **Dissociation.** Flow switches to buffer only. No fresh target arrives, so bound target falls off and the response decays. The information lives in the **shape**, not the height. The steepness of the climb encodes `kon`, the steepness of the decay encodes `koff`, and the concentration-dependent spacing between curves is what lets a global fit separate the two. A single concentration can't. That's why characterization runs a series rather than one point: four concentrations spanning roughly a hundred-fold range, plus a zero-concentration blank. `koff` is the one thing that does **not** change with concentration. Every curve in a family should fall away at the same rate during dissociation, starting from whatever height it reached. Curves that decay at visibly different rates, or that cross during dissociation, are a sign the interaction isn't a simple 1:1. ## The three numbers Every characterization fit reports the same three values, each with a 95% confidence interval. | Value | What it is | Where it comes from | | - | - | - | | `kon` | Association rate (M⁻¹s⁻¹): how fast target finds and binds | Steepness of the association climb, across concentrations | | `koff` | Dissociation rate (s⁻¹): how fast it lets go | Steepness of the dissociation decay | | `KD` | Affinity (M) = `koff` / `kon`, the concentration at which half your protein is occupied | Derived from the two rates | Lower `KD` is tighter: a 1 nM binder is 1000× stronger than a 1 µM one. But two designs can reach the **same** `KD` by opposite routes (one fast-on/fast-off, the other slow-on/slow-off), and they often behave differently in your application. A slow `koff` (long residence time) is frequently what matters most. That's why we report the rates, not just the affinity. `koff` is usually the more decision-relevant rate. Read it directly off the dissociation phase: a curve that barely comes down has a slow `koff` and a long residence time, regardless of how fast it went on. ## Screening and characterization The difference between the two is simply **how many concentrations we run**, and that determines whether you get a ranking or a real number. Most campaigns do both: screen the library wide, then characterize the handful of winners. | | Binding screening | Affinity characterization | | - | - | - | | **Concentrations** | 2, plus a zero-concentration blank | 4, plus a zero-concentration blank | | **You get** | Strong / Moderate / Weak / Non-binder, with ranked responses | Quantitative `KD`, `kon`, `koff` with confidence intervals and fit diagnostics | | **`KD` precision** | Indicative bucket | Quantitative, ≈ 0.1 nM–10 µM | | **Best for** | Triaging large libraries, down-selection | Lead optimization, benchmarking, mechanism studies | | **The question** | Which of my designs bind? | Exactly how good is my best one? | Why the extra concentrations matter: a single point can be explained by many curves, but a series spanning several concentrations constrains the fit and lets us separate `kon` from `koff`. That's why a characterization `KD` is trustworthy where a screening estimate is only indicative. ## Reading your results Every measured design gets a **binding call**. How its strength is reported then depends on the depth you ran: a quick bucket from **screening**, or precise kinetics from **characterization**. ### Did it bind? | Call | What it means | | - | - | | **True** | A clear binder: signal rises distinctly above the controls. | | **False** | The protein expressed, but binding sits at or below control signals. No interaction detected. | | **Unknown** | We couldn't make the call, usually because of no/low expression or signals too marginal to trust. | ### How strong? From a screening run Screening sorts each binder into one of three affinity buckets, enough to rank a library and decide what to pursue. | Bucket | Range | | - | - | | **Strong** | `KD` \< 50 nM | | **Moderate** | 50 nM–1 µM | | **Weak** | > 1 µM | ### How strong? From a characterization run A full concentration series resolves the interaction into quantitative kinetics, each reported with a 95% confidence interval, alongside fit-quality diagnostics so you can judge how much to trust the numbers. | | Value | 95% CI | | - | - | - | | `KD` | 4.2 nM | 3.6–4.9 nM | | `kon` | 2.1 × 10⁵ M⁻¹s⁻¹ | 1.9–2.3 × 10⁵ | | `koff` | 8.9 × 10⁻⁴ s⁻¹ | 8.1–9.6 × 10⁻⁴ | Each value comes from the global fit across the whole series; the confidence interval shows how tightly that fit is constrained, and the diagnostics (below) flag any curve worth a closer look. Binding depends on expression. We can only measure binding for protein that actually made it onto the sensor. A poorly-expressed design gives low signal-to-noise, wide CIs, and often an **Unknown** call rather than a `KD`. Confirming [expression](/docs/experiment-types/expression) first is the surest route to clean, tightly-fitted curves. ## Judging fit quality The fitted numbers are only as good as the fit they came from. Every characterization result ships with diagnostics, both in the portal and in the `fit_data/` folder of your [data package](/docs/experiment-setup/binding-data-package), so you can judge each one yourself. Four things to check: * **Confidence intervals.** Each rate carries a 95% CI. Tight, symmetric intervals (a few percent of the value) mean the fit is well-constrained. A CI that spans an order of magnitude means the data don't pin that parameter down, so treat the number as indicative, not quantitative. * **Fit error (MAE).** The mean absolute error between the modelled and measured curves, reported per replicate. Low MAE relative to the signal is good. The stronger test is the **residuals**: plot model-minus-data and you want flat, random noise around zero. Systematic structure, like a bowed or S-shaped residual, means the model isn't capturing what the surface actually did. * **Rmax.** The estimated maximum response, i.e. a fully-loaded surface. A physically sensible `Rmax` should agree with the **theoretical Rmax** the surface can support: `Rmax(theoretical) = (analyte MW / ligand MW) × immobilized ligand level × binding sites per ligand`. In practice the measured `Rmax` usually lands around **30–70%** of that value. A measured `Rmax` far **below** theoretical (a few percent of predicted, in the worst cases) points to a misfolded or aggregating surface; an `Rmax` **above** theoretical points to non-specific binding, analyte aggregation, or an association phase that never curved enough to constrain the fit. * **Range.** We reliably quantify `KD` from roughly **0.1 nM to 10 µM**. Outside that window a value may be reported as a bound (see below) rather than a point estimate. ## Common curve shapes Most designs give a clean 1:1 curve. When they don't, the shape tells you why, and whether the fitted `KD` still means what you think. Use this as a lookup.
Ideal 1:1 (Langmuir). Smooth exponential rise to a clear plateau during association; smooth single-exponential decay at the same rate for every curve during dissociation. Curves fan out by concentration, and the highest concentrations flatten at the same height because they have saturated the surface (`Rmax`). Residuals are flat noise. Trust the numbers: this is the case the fit is built for.
Never reaches plateau. Association is still climbing when the injection ends, with no curvature. Either kon is slow or every concentration sits below KD. The fit can still work if dissociation is well-defined, but KD leans on extrapolation; widen the concentration range to tighten it.Suggestion. Add higher concentrations, or extend the association time, so the curves approach saturation and pin down KD.
Flat dissociation (no come-off). The decay barely drops within the dissociation window. The target essentially doesn't let go. koff is slower than the experiment can measure, so it (and therefore KD) is reported as an upper bound: "≤" a value, not "=". Typical of very tight binders. Longer dissociation times can pull it into range.Suggestion. Ask for a longer dissociation window (up to 30–60 min) so koff can be resolved; otherwise KD stays an upper bound.
Fast-on / fast-off (square wave). Rapid rise, low plateau, rapid return to baseline the instant buffer flows. A weak, fast-equilibrating interaction where the kinetics are too fast to resolve. Here steady-state (equilibrium) analysis (response at plateau vs. concentration) gives a more reliable KD than the kinetic fit.Suggestion. Use steady-state (equilibrium) analysis, and widen the concentration range so it brackets KD.
Mass-transport limitation. Association looks oddly linear instead of exponential because target is binding faster than flow can replenish it at the surface. This underestimates kon. Diagnostic: apparent kon changes with flow rate. We mitigate it with lower ligand density and higher flow; if it persists we flag the affected fits.Suggestion. Lower the ligand density and raise the flow rate, then confirm kon no longer changes with flow.
Biphasic / heterogeneous. Two visibly different phases: a fast then a slow component in the association or (more often) the dissociation. Points to avidity, a heterogeneous or partly-misfolded ligand population, a conformational change, or aggregation. A 1:1 fit will show systematic residuals; we report these with caveats and, where it helps, an alternative model.Suggestion. Ask for the flipped assay and HPLC-SEC to find the cause (avidity, heterogeneity, or aggregation); we can also fit a bivalent or conformational model, or report ranking-only.
Non-specific binding / drift. Signal keeps drifting upward during dissociation, or the reference channel itself responds. A "sticky" analyte or surface inflates apparent binding. Reference and blank (buffer) subtraction remove most of it; a curve that survives subtraction is real.Suggestion. Improve reference and blank subtraction, adjust the buffer or blocking, or lower the analyte concentration; a curve that survives subtraction is real.
Super-stoichiometric (aggregation). Response climbs past a sensible Rmax without saturating, because more mass lands than a monolayer of target should allow, usually from analyte self-association at the surface. The KD from a 1:1 fit is unreliable; cleaner material or lower concentrations are the fix.Suggestion. Re-run with cleaner, monomeric material (SEC-purified) at lower concentrations, and use a dilution series to confirm; the 1:1 KD here is not reliable.
Before quoting a `KD`, glance at the sensorgram PNG in your data package and match it to one of the shapes above. Ninety seconds of eyeballing catches the cases where a number is technically fitted but not trustworthy. ## When the curve isn't 1:1 When a curve doesn't fit a clean 1:1 model, the two most common reasons are **avidity** and **aggregation**, and each changes what the `KD` actually means. We fit a 1:1 model first; when the shape rejects it, we fit alternative models (bivalent, conformational), and when a curve can't be trusted at all we report the binder as a ranked hit **without** a `KD` rather than quote a number we don't believe. ### Apparent KD and avidity Binding curves are fit assuming a 1:1 interaction. Some systems show **avidity**, where a binder or a multivalent target engages more than one site at once. Avidity slows dissociation, so the interaction looks stronger than it is, and the reported `KD` is an **apparent KD**, not a true thermodynamic constant. This is common when the target is oligomeric (dimeric, trimeric, or Fc-tagged): the observed `koff` is artificially slow and the `KD` artificially tight. Avidity can be a deliberate design feature (a bispecific engaging two epitopes on the same target can dissociate several-fold more slowly by design) or an artifact of how the protein sits on the surface. Because of this, the platform is tuned to **rank binders consistently** rather than to report absolute biophysical constants. To separate true affinity from surface avidity, ask us for a **flipped assay**: we put the target on the sensor and titrate your binder in solution. A genuine 1:1 interaction gives a clean fit; a shape that only looked tight because of avidity resolves. ### Aggregation A misfolded or aggregating construct can produce a signal that reads tight but isn't real binding. The tells are consistent: **unusually high loading for the protein's size**, a **response well below the expected Rmax**, **very slow association and dissociation**, and a sensorgram that won't fit a clean 1:1 (often resembling non-specific binding). We flag these and confirm them with orthogonal checks: a **dilution series** (real binding tracks loading, aggregation doesn't), the flipped assay above, an **extended dissociation** window, and **HPLC-SEC** to see aggregation directly. When aggregation is confirmed, the `KD` isn't reliable, so we revise or withhold it rather than report it. Both platforms can agree and still be wrong. In one revalidation, aggregating binders reproduced the *same* false-positive signal on both SPR and BLI; it took the flipped assay and HPLC-SEC to catch it. When a number looks too good, the check is the biophysics (loading, `Rmax`, curve shape), not just the goodness of fit. ## What you get back Beyond the summary call and kinetic values in the portal, every binding experiment comes with a downloadable **data package**: the underlying traces, fits, and QC, ready for your own analysis. Everything in it is safe to share and pipeline-friendly. | File | What it is | | - | - | | **Sensorgrams** | A binding-curve PNG for every sample and replicate, for quick visual QC without touching the raw data. | | **Raw traces** (`.csv`) | Instrument readouts as time vs. response in nanometers, one file per concentration. | | **Fitted curves** | The modelled sensorgrams for approved fits; overlay them on the raw traces to reproduce the kinetics. | | **Per-replicate QC** | Fit error (MAE), method, and estimated `Rmax` so you can judge each fit yourself. | ## FAQs A `KD` requires enough of your protein on the sensor to give clean signal. If expression is none or low, signal-to-noise is too poor for a reliable fit, so the result comes back as **Unknown** rather than a number. Stronger expression yields cleaner curves and tighter fits. Roughly **0.1 nM to 10 µM**. Accuracy tapers at the extremes (very tight or very weak interactions are harder to pin down), but we can tune concentrations and contact times to bias the assay toward either end when you know what you're chasing. We record response over time at 5 Hz and fit a 1:1 binding model. When several concentrations are run, we fit them together (**global fitting**) so a single `kon`/`koff` pair has to explain the whole family of curves, a much stronger constraint than fitting one trace alone. Screening uses only two concentrations to triage binders quickly, so its `KD` carries more uncertainty. Characterization runs a full series designed to resolve `kon`, `koff`, and `KD` precisely. Treat screening values as a ranking, not a measurement. Curves that don't fit a clean 1:1 model can point to a multi-step mechanism, conformational change, or avidity. Relative rankings still hold, but resolving precise kinetics may need an expanded concentration series. We'll flag these when we see them. We screen new targets for non-specific binding (NSB) and adjust buffers or suppliers to suppress it. Heavy NSB can show up as negative-shift curves after reference subtraction, a tell we watch for during QC. Yes. We run cross-reactivity and polyspecificity panels (e.g. BVP, BSA/HSA) to check how selective your binder is. Full-serum profiling is in development. Yes. We run neutralization, inhibition, and competition formats (IC50 and epitope-access questions) on request. **Ready to run a binding experiment?** Configure your target, upload sequences, and get a quote in minutes at [start.adaptyvbio.com/binding](https://start.adaptyvbio.com/binding). ## See also What the assay measures, and screening vs. characterization. Every folder and file in your download, including the fit diagnostics referenced here. Clean binding data starts with protein that expresses well. # Improve Protein Expression Source: https://docs.adaptyvbio.com/guides/improve-protein-expression Practical strategies to get your proteins expressing better on our platform ## Common sequence issues to fix early * Unpaired cysteines can create unwanted disulfides. Remove or pair them unless they are functionally required. * High hydrophobic content and long hydrophobic patches often drive aggregation. Prefer balanced hydropathy and short, flexible linkers between domains. ## Recommended solubility and stability predictors * [NetSolP](https://services.healthtech.dtu.dk/service.php?NetSolP-1.0): fast sequence-based solubility screen for triage. * [SoluProt](https://loschmidt.chemi.muni.cz/soluprot/): predicts soluble expression in E. coli from sequence features. * [SolubleMPNN](/wiki/models/solublempnn): solubility‑oriented variants of ProteinMPNN for redesigning constructs toward higher solubility (commonly used as a default starting point in redesign). See also [ProteinMPNN](/wiki/models/proteinmpnn). * [ESM](/wiki/models/esm): use sequence log‑likelihoods to deprioritize hard‑to‑express variants. * [ipTM](/wiki/models/iptm) ([AlphaFold‑Multimer](/wiki/models/alphafold-multimer)): interface quality metric that can correlate with complex stability in binder design workflows. * [pSAE](/wiki/models/psae): exposure‑based measures (e.g., percent solvent‑accessible exposed hydrophobicity) are useful for ranking aggregation risk; implementations vary across toolkits. Definitions and references: [SolubleMPNN](/wiki/models/solublempnn), [ProteinMPNN](/wiki/models/proteinmpnn), [ESM](/wiki/models/esm), [ipTM](/wiki/models/iptm), [AlphaFold‑Multimer](/wiki/models/alphafold-multimer), [pSAE](/wiki/models/psae). Workflow: Filter with NetSolP/SoluProt → rank by ESM log‑likelihoods → redesign with SolubleMPNN‑style constraints → re‑screen. ## See also * [Supported Protein Formats](/docs/experiment-setup/supported-protein-formats) * [Creating Experiments](/docs/experiment-setup/creating-experiments) # Coming Soon Source: https://docs.adaptyvbio.com/guides/protein-design-101/overview We're working on writing guides to help you get started with protein design. # BLI methods Source: https://docs.adaptyvbio.com/wiki/methods/bli-methods Standard methods for Adaptyv BLI binding characterization on Gator Bio instruments This page holds the standard methods for our [BLI](/wiki/technologies/BLI) binding characterization assay. The concentration series, step timings and capture format for your experiment can differ, so check your [Binding Data Package](/docs/experiment-setup/binding-data-package) for the values used in your run. For the SPR equivalent, see [SPR methods](/wiki/methods/spr-methods). ## Cell-free expression of protein ligands DNA constructs encoding the ligands, each fused to a C-terminal assay tag, were designed by reverse-translating the target protein sequences. The sequences were optimized for manufacturability and yield using codon optimization algorithms to maximize expression efficiency. The optimized DNA constructs of the variants and the 3′ fragment containing the linker and affinity tags were ordered as Gene Fragments from Twist Bioscience. Constructs were assembled using the NEBuilder HiFi DNA Assembly Kit (NEB) in 2 μL reactions. The assembled products were characterized by capillary electrophoresis (Agilent ZAG DNA Analyzer, ZAG-135-5000 Kit, FA/ZAG 96-Capillary Array Short, 33 cm), and their concentrations were measured using the Qubit DNA Quantification Kit (Invitrogen). Ligand expression was carried out in 8 μL reactions using an optimized prokaryotic in vitro translation system and 4 nM of assembled gene fragment. Reactions were incubated at 37 °C for 8 hours. Post-expression, protein concentration and yield were normalized using an affinity-based quantification assay. ## Affinity characterization by biolayer interferometry (BLI) Kinetic binding measurements were performed on a BLI instrument (Gator Bio) using Strep-Tactin XT probes to capture Twin-Strep-tagged ligands. ### Sensor preparation and capture Probes were equilibrated in running buffer before use. Ligands were captured with the following sequence: * **Baseline 1:** 120 s in running buffer * **Ligand loading:** 120 s (target loading shift 0.5–1.0 nm) * **Baseline 2:** 200 s in running buffer Running buffer was 10 mM HEPES, 150 mM NaCl, 3 mM EDTA, 0.2% Tween-20, pH 7.4. Temperature was held at 25 °C and data were sampled at 5 Hz. ### Association and dissociation (multi-cycle kinetics) Antigen solutions were prepared in running buffer as a half-log dilution series of 4 concentrations (1000 nM to 30 nM). Each cycle consisted of: * **Association:** 220 s in antigen solution * **Dissociation:** 240 s in running buffer Between cycles, probes were regenerated in 10 mM glycine-HCl, pH 1.5, applied 5 times for 10 s each, followed by neutralization in running buffer. Negative controls (buffer-only and a non-binding ligand) were included for reference subtraction and drift correction. ### Data processing and model fitting Data were processed and fitted globally to a 1:1 Langmuir binding model using Adaptyv fitting software. All sensorgrams underwent standardized preprocessing and curve fitting. Preprocessing included trimming to the relevant phases (association, dissociation, baseline), correcting signal jumps at phase transitions, aligning association and dissociation phases, and subtracting baseline and reference signals. Fitting proceeded through multiple methods in a prioritized order. Initial fits were performed individually using global fitting, followed by full, dissociation-only or slope-based models. Where these were not possible, group-level models were applied: equilibrium (saturation), constant (flat) and semi-log linear (linear). Final kinetic parameters (kon, koff, KD) were selected based on fit quality. Global fitting was applied using a 1:1 model across all concentrations. In global mode, koff and KD were fitted directly, and kon was calculated as koff / KD. Fits were scored and filtered on quality metrics. Ligands were classified as binders or non-binders based on the presence of quantifiable binding curves and calculated KD values. Where a ligand produced a significant signal shift during the association phase (≥300% over the negative control) but the signal could not be reliably fit, the binding label was assigned based on the magnitude of the observed shift. ## Related pages * [BLI](/wiki/technologies/BLI) * [SPR methods](/wiki/methods/spr-methods) * [Binding](/docs/experiment-types/binding) * [Binding Data Package](/docs/experiment-setup/binding-data-package) # SPR methods Source: https://docs.adaptyvbio.com/wiki/methods/spr-methods Standard methods for Adaptyv SPR binding characterization on the Carterra LSA XT This page holds the standard methods for our [SPR](/wiki/technologies/SPR) binding characterization assay. The concentration series, cycle timings and capture format for your experiment can differ, so check your [Binding Data Package](/docs/experiment-setup/binding-data-package) for the values used in your run. For the BLI equivalent, see [BLI methods](/wiki/methods/bli-methods). ## Cell-free expression of protein ligands DNA constructs encoding the ligands, each fused to a C-terminal assay tag, were designed by reverse-translating the target protein sequences. The sequences were optimized for manufacturability and yield using codon optimization algorithms to maximize expression efficiency. The optimized DNA constructs of the variants and the 3′ fragment containing the linker and affinity tags were ordered as Gene Fragments from Twist Bioscience. Constructs were assembled using the NEBuilder HiFi DNA Assembly Kit (NEB) in 2 μL reactions. The assembled products were characterized by capillary electrophoresis (Agilent ZAG DNA Analyzer, ZAG-135-5000 Kit, FA/ZAG 96-Capillary Array Short, 33 cm), and their concentrations were measured using the Qubit DNA Quantification Kit (Invitrogen). Ligand expression was carried out in 8 μL reactions using an optimized prokaryotic in vitro translation system and 4 nM of assembled gene fragment. Reactions were incubated at 37 °C for 8 hours. Post-expression, protein concentration and yield were normalized using an affinity-based quantification assay. ## Surface plasmon resonance (SPR) affinity characterization Binding kinetics of the expressed ligands to their cognate targets were characterized using surface plasmon resonance (SPR) on a Carterra LSA XT instrument. Twin-Strep-tagged ligands were captured on a sensor surface functionalized with Strep-Tactin XT (IBA Lifesciences), followed by sequential injections of increasing antigen concentrations. ### Chip preparation (Strep-Tactin XT immobilization) Surface functionalization of the carboxymethylated chip was performed following a multi-step chip preparation protocol: 1. **Conditioning:** the sensor surface was conditioned with 50 mM NaOH to remove residual contaminants and prepare the surface for activation. 2. **Activation:** the surface was activated using freshly prepared EDC/NHS (1-ethyl-3-(3-dimethylaminopropyl)carbodiimide/N-hydroxysulfosuccinimide) (Xantec) solution to form reactive esters. 3. **Capture:** Strep-Tactin XT was diluted to 50 μg/mL in 10 mM sodium acetate buffer (pH 4.5) and injected onto the activated surface for covalent coupling. 4. **Quenching:** excess reactive groups were quenched with 1 M ethanolamine hydrochloride (pH \~8.5). 5. **Wash:** the surface was washed with 0.1 M sodium borate, 1 M NaCl, pH 9.0 to remove loosely bound material. Reference and capture sensors underwent identical treatment, allowing for accurate background subtraction. ### Ligand capture and kinetics Following surface preparation, Twin-Strep-tagged ligands were captured on the immobilized Strep-Tactin XT using the multichannel head (96-channel array) with bidirectional flow for 750 s, followed by a 600 s baseline step in running buffer. The analyte (for example, the SARS-CoV-2 antigen) was diluted in running buffer (10 mM HEPES, 150 mM NaCl, 3 mM EDTA, 0.05% Tween-20, pH 7.4) to 7 concentrations in a half-log dilution series (for example, 1000 nM to 1 nM). Cycles were run over increasing analyte concentrations as a single-cycle kinetic assay, without intermediate regeneration, at a flow rate of 50 μL/min. Each assay cycle consisted of: * **Baseline:** 60 s of buffer-only flow * **Association:** 300 s of analyte injection * **Dissociation:** 600 s of buffer-only flow After each full concentration series, the chip surface was regenerated with 10 mM glycine-HCl (pH 1.5) for 5 min, followed by a 20 min wash in running buffer. ### Data processing and analysis Data were processed and fitted globally to a 1:1 Langmuir binding model using Adaptyv fitting software. All sensorgrams underwent standardized preprocessing and curve fitting. Preprocessing included trimming to the relevant phases (association, dissociation, baseline), correcting signal jumps at phase transitions, aligning association and dissociation phases, and subtracting baseline and reference signals. Fitting proceeded through multiple methods in a prioritized order. Initial fits were performed individually using global fitting, followed by full, dissociation-only or slope-based models. Where these were not possible, group-level models were applied: equilibrium (saturation), constant (flat) and semi-log linear (linear). Final kinetic parameters (kon, koff, KD) were selected based on fit quality. Global fitting was applied using a 1:1 model across all concentrations. In global mode, koff and KD were fitted directly, and kon was calculated as koff / KD. Fits were scored and filtered on quality metrics. Ligands were classified as binders or non-binders based on the presence of quantifiable binding curves and calculated KD values. Where a ligand produced a significant signal shift during the association phase (≥300% over the negative control) but the signal could not be reliably fit, the binding label was assigned based on the magnitude of the observed shift. ## Related pages * [SPR](/wiki/technologies/SPR) * [BLI methods](/wiki/methods/bli-methods) * [Binding](/docs/experiment-types/binding) * [Binding Data Package](/docs/experiment-setup/binding-data-package) # AlphaFold‑Multimer Source: https://docs.adaptyvbio.com/wiki/models/alphafold-multimer Structure prediction for protein complexes with interface confidence metrics (e.g., ipTM) AlphaFold‑Multimer predicts complex structures and provides confidence metrics such as ipTM for interfaces and pTM for overall topology. * **Type**: Structure prediction (multimer) * **Goal**: Propose complex models and interface confidence estimates * **Input**: Protein sequences (FASTA) with pairing map; optional templates/constraints Resources: [alphafold](https://github.com/deepmind/alphafold) # ESM Source: https://docs.adaptyvbio.com/wiki/models/esm Evolutionary Scale Modeling: protein LMs for representation, structure, and design ESM is a family of large protein language models trained on evolutionary-scale sequence data. Variants (ESM-1b/2/ESMFold/ESM-3) support representation learning, zero-shot mutational effects, and structure prediction. Protein language model Embeddings, structure prediction (ESMFold), design Amino acid sequences (e.g., FASTA) Meta AI MIT ## Resources * GitHub: [facebookresearch/esm](https://github.com/facebookresearch/esm) * Paper (ESMFold): [Protein structure prediction using ESM](https://www.science.org/doi/10.1126/science.ade2574) * Model card(s): see repo Use ESM embeddings for downstream tasks (e.g., fitness prediction) or ESMFold for fast single-sequence structure prediction. # ipTM Source: https://docs.adaptyvbio.com/wiki/models/iptm Interface predicted TM-score from AlphaFold‑Multimer for complex/interface quality ipTM is an AlphaFold‑Multimer metric estimating interface quality in protein complexes. Higher scores generally indicate better‑packed and more reliable interfaces. * **Type**: Structure metric (AlphaFold‑Multimer interface confidence) * **Goal**: Rank complexes by interface quality/confidence * **Input**: Paired protein sequences and AlphaFold‑Multimer predictions Resources: [alphafold](https://github.com/deepmind/alphafold) # pSAE Source: https://docs.adaptyvbio.com/wiki/models/psae Percent Solvent‑Accessible Exposed hydrophobicity (and related exposure metrics) pSAE denotes exposure‑based heuristics (e.g., percent of solvent‑accessible exposed hydrophobic surface or residues) used to estimate aggregation risk. * **Type**: Exposure metric (solvent‑accessible hydrophobic exposure) * **Goal**: Identify/flag aggregation‑prone designs * **Input**: 3D structure or predicted SASA; sequence‑derived proxies (hydropathy windows) Notes: Implementations vary across toolkits; ensure consistent residue/burial definitions. # SolubleMPNN Source: https://docs.adaptyvbio.com/wiki/models/solublempnn Sequence design with solubility-aware objectives SolubleMPNN extends ProteinMPNN with solubility-aware training/objectives to bias designed sequences toward improved expression and solubility. Inverse folding + solubility bias Higher expression/solubility Backbone structure (experimental or predicted) Designed sequences ## Resources * Reference impls: community forks built on ProteinMPNN * Related: NetSolP (solubility prediction) — [paper](https://academic.oup.com/bioinformatics/article/38/4/941/6444984) If no public canonical repo is available, implement as a ProteinMPNN post-filter or multi-objective scoring with a solubility model. # Fab Source: https://docs.adaptyvbio.com/wiki/proteins/fab Antibody fragment containing one antigen-binding site Fab fragments contain one complete antigen-binding site with both heavy and light chain variable and constant domains. \~50 kDa (1/3 of IgG) Monovalent (1 binding site) More stable than scFv Bacterial, yeast, mammalian ## Structure Fab maintains the native antibody binding interface while being significantly smaller than full IgG. * **VH + CH1** domains (heavy chain) * **VL + CL** domains (light chain) * Connected by disulfide bonds ## Key Applications * **Therapeutics** - Reduced immunogenicity * **Diagnostics** - Fast tissue penetration * **Crystallography** - Easier to crystallize * **Research** - Structural studies # IgG Source: https://docs.adaptyvbio.com/wiki/proteins/igg Full-length antibody format with two antigen-binding sites IgG is the standard full-length antibody format used in most therapeutic monoclonal antibodies, featuring two identical antigen-binding sites. \~150 kDa Bivalent (2 binding sites) \~3 weeks in humans Mammalian cells ## Structure Components * **Heavy chains** (2x \~50 kDa) + **Light chains** (2x \~25 kDa) * **Fc region** - Enables effector functions * **Fab regions** - Two identical antigen-binding sites * **Hinge region** - Provides flexibility Most common therapeutic format with strong effector functions Reduced effector functions, suitable for some therapeutics Minimal effector functions when immune activation is undesired IgG represents the gold standard for therapeutic antibodies due to its bivalent binding, long half-life, and well-characterized manufacturing processes. # Natural Ligands Source: https://docs.adaptyvbio.com/wiki/proteins/ligands Endogenous peptides, proteins, or small molecules that bind biological targets Natural ligands are endogenous molecules—peptides, proteins, lipids, nucleic acids, or small molecules—that bind specifically to receptors, enzymes, or other macromolecules to elicit biological effects. Peptides, proteins, lipids, metabolites, nucleic acids Native affinities tuned by evolution for function High; often context- and isoform-dependent Endogenous or purified from natural sources ## Key Concepts Studying native ligand–receptor pairs informs mechanism and guides therapeutic mimicry or antagonism. * **Orthosteric vs. allosteric** interactions modulate signaling differently * **Kinetics** (on/off rates) can be as important as affinity * **Post-translational modifications** influence binding and function Natural heterogeneity and context-dependent behavior can complicate standardization and reproducibility. ## Applications Map signaling pathways and validate targets using native binders. Design peptide/protein mimetics or inhibitors based on native interactions. Use natural ligands as capture agents or biomarkers in assays. Where relevant, see related formats: `peptides`, `miniproteins`, and antibody-derived formats (`IgG`, `Fab`, `scFv`, `VHH`). # Miniproteins Source: https://docs.adaptyvbio.com/wiki/proteins/miniproteins De novo or engineered small proteins with stable, designed folds Miniproteins are compact protein scaffolds (typically \< 80 amino acids) engineered or designed to adopt specific, stable folds for binding or catalysis. \~3–10 kDa (30–90 aa) Stable designed topologies (helix bundles, β-sheets) High thermostability; protease resistant when well-packed Bacterial or cell-free expression; chemical synthesis ## Unique Features Computational design enables shape-complementary interfaces with high affinity and specificity. * **De novo scaffolds** not constrained by natural antibody frameworks * **High expression** and straightforward manufacturing * **Robustness** for harsh assay and environmental conditions Design accuracy and foldability depend on sequence-structure mapping; experimental validation is essential. ## Applications Target-specific binding domains for therapeutics, diagnostics, and targeting. Small catalytic scaffolds or cofactor-binding mini-enzymes. Modular components in synthetic biology and nanotechnology. Miniproteins bridge the gap between peptides and antibodies: small, stable, and engineerable with tailor-made interfaces. # Peptides Source: https://docs.adaptyvbio.com/wiki/proteins/peptides Short amino acid chains used as binders, modulators, and scaffolds Peptides are short polymers of amino acids that can bind targets, modulate signaling, or serve as modular building blocks in therapeutics and diagnostics. \~2–50 amino acids (∼0.2–5 kDa) Linear or cyclic; natural or synthetic Tunable via cyclization and non-natural residues Solid-phase synthesis or recombinant ## Key Features Cyclization and incorporation of D-amino acids or peptidomimetics can dramatically improve stability and potency. * **High specificity** with small footprint * **Rapid synthesis** and optimization cycles * **Amenable to conjugation** (labels, payloads, PEG) Unmodified linear peptides often have short serum half-life due to proteolysis and renal clearance. ## Applications Receptor agonists/antagonists, enzyme inhibitors, and signaling modulators. Direct payloads to tissues or cells; imaging probes and ADC-like constructs. Short, robust binders for assays and biosensors. Peptide libraries enable high-throughput discovery (e.g., phage display, mRNA display) of potent binders with tailored properties. # Protein Conjugates Source: https://docs.adaptyvbio.com/wiki/proteins/protein-conjugates We provide binding targets expressed with various conjugates Protein conjugates are powerful tools in biological research that combine proteins with various chemical groups to enable detection, visualization, and tracking. ## What are Protein Conjugates? A conjugated protein contains amino acids plus an additional non-peptide chemical component (called a prosthetic group) attached through covalent bonding or weak interactions. These modifications enable specialized biological functions and allow proteins to perform complex tasks beyond what simple proteins can achieve. [Learn more](https://en.wikipedia.org/wiki/Conjugated_protein) ## Common Protein Conjugates ### Chemical Modifications #### Biotin A small molecule (244.31 g/mol) that binds with extremely high affinity to streptavidin and avidin. Biotinylation is rapid, specific, and unlikely to disturb protein function, making it ideal for protein purification, detection, and tracking applications. [Learn more](https://en.wikipedia.org/wiki/Biotinylation) #### Azide A chemical group used in click chemistry reactions for bioconjugation. Azide-modified proteins can be specifically labeled through copper-catalyzed or strain-promoted cycloaddition reactions, enabling precise and bioorthogonal protein labeling. ### Unconjugated Proteins in their native state without any chemical modifications or labels. Unconjugated proteins are used when detection labels might interfere with function or when the protein itself is the desired end product. ### Fluorescent Dyes #### AF488 (Alexa Fluor 488) A bright green fluorescent dye that excites at 488 nm and emits at 519 nm. AF488 is more photostable and pH-insensitive than traditional fluorescein, making it ideal for fluorescence microscopy, flow cytometry, and immunofluorescence applications. [Learn more](https://www.thermofisher.com/us/en/home/life-science/cell-analysis/fluorophores/alexa-fluor-488.html) #### AF555 (Alexa Fluor 555) An orange fluorescent dye in the Alexa Fluor family, optimized for excitation in the orange spectrum. Like other Alexa dyes, it offers superior brightness and photostability compared to traditional fluorophores. [Learn more](https://www.thermofisher.com/ch/en/home/life-science/cell-analysis/fluorophores/alexa-fluor-555.html) #### AF647 (Alexa Fluor 647) A far-red fluorescent dye that provides deep tissue penetration due to its longer wavelength. AF647 is particularly useful for multicolor imaging applications and offers reduced autofluorescence. [Learn more](https://www.thermofisher.com/ch/en/home/life-science/cell-analysis/fluorophores/alexa-fluor-647.html) #### FITC (Fluorescein Isothiocyanate) A classic green fluorescent dye that excites at \~495 nm and emits at \~519 nm. While prone to photobleaching, FITC remains widely used due to its established protocols and compatibility with common laser lines. [Learn more](https://en.wikipedia.org/wiki/Fluorescein_isothiocyanate) #### PE (Phycoerythrin) An extremely bright fluorescent protein (\~240 kD) containing 25 fluorescent molecules. PE emits at \~570 nm and is primarily used for flow cytometry due to its exceptional brightness and quantum efficiency. [Learn more](https://www.drmr.com/abcon/PE.html) #### APC (Allophycocyanin) A large fluorescent protein used in flow cytometry and other fluorescence-based applications. APC provides bright far-red fluorescence and is often used in multicolor experiments. [Learn more](https://www.thermofisher.com/ch/en/home/life-science/cell-analysis/fluorophores/allophycocyanin.html) ### Enzymes #### HRP (Horseradish Peroxidase) A versatile enzyme conjugate used in western blots, ELISA, and immunohistochemistry. HRP catalyzes reactions that produce colored, fluorescent, or luminescent products, enabling sensitive detection with signal amplification up to 1000-fold. [Learn more](https://en.wikipedia.org/wiki/Horseradish_peroxidase#Applications) #### ALP (Alkaline Phosphatase) An enzyme conjugate commonly used in ELISA and immunohistochemistry. ALP catalyzes the conversion of colorless substrates into colored products, providing an alternative to HRP with different substrate options. ### Fusion Proteins #### GFP Fusion Green Fluorescent Protein can be genetically fused to target proteins, allowing real-time visualization in living cells. GFP fusions enable tracking of protein movement, localization, and interactions without disrupting cellular processes. [Learn more](https://en.wikipedia.org/wiki/Green_fluorescent_protein) #### RFP Fusion Red Fluorescent Protein fusions offer advantages over GFP including lower phototoxicity, reduced autofluorescence, and deeper tissue penetration. Popular RFP variants include mCherry, mRuby, and TagRFP. [Learn more](https://www.thermofisher.com/ch/en/home/life-science/cell-analysis/fluorophores/red-fluorescent-protein.html) ## Choosing the Right Conjugate When selecting a protein conjugate, consider: * **Application requirements**: Different conjugates excel in different applications (e.g., PE for flow cytometry, HRP for western blots) * **Detection method**: Match the conjugate to your available equipment and detection systems * **Multiplexing needs**: For multicolor experiments, choose conjugates with well-separated spectral properties * **Sensitivity requirements**: Enzyme conjugates like HRP provide signal amplification for detecting low-abundance targets ## Key Advantages by Type * **Fluorescent dyes**: Direct visualization, multicolor capability, quantitative analysis * **Enzymes**: Signal amplification, versatile substrate options, high sensitivity * **Fusion proteins**: Live-cell compatibility, genetic encoding, minimal perturbation * **Chemical modifications**: Specific targeting, versatile applications, stable linkages Understanding these conjugates helps researchers select the most appropriate tools for their specific experimental needs, ensuring optimal results in protein detection and analysis. # Expression Systems Source: https://docs.adaptyvbio.com/wiki/proteins/protein-expression-systems We provide binding targets expressed in various expression systems Protein expression systems are biological platforms used to produce proteins for research, therapeutic, and industrial applications. Each system has unique characteristics that make it suitable for different types of proteins and applications. ## What are Protein Expression Systems? Protein expression systems are biotechnological processes that manipulate cells to produce specific proteins. The process involves: * Introducing genetic material (DNA) into host cells * Transcribing DNA to messenger RNA * Translating mRNA into proteins * Ensuring proper protein folding and modifications [Learn more about protein production systems →](https://en.wikipedia.org/wiki/Protein_production) ## Common Expression Systems ### E. coli (Escherichia coli) E. coli is the most widely used bacterial expression system due to its simplicity and cost-effectiveness. **Key Advantages:** * **Fast growth**: Rapid cell division allows quick protein production * **Low cost**: Inexpensive culture media and simple equipment requirements * **High yields**: Can produce large amounts of protein per culture volume * **Well-characterized**: Decades of research have optimized protocols **Best for:** * Simple proteins without complex modifications * Research-scale protein production * Proteins that don't require glycosylation E. coli has been instrumental in producing therapeutic proteins like human insulin and is particularly useful for proteins that can be expressed in their active form without extensive post-translational modifications. [Learn more about expression in E. coli →](https://en.wikipedia.org/wiki/Escherichia_coli#Therapeutic_use) ### CHO (Chinese Hamster Ovary) Cells CHO cells are the most common mammalian expression system used in biopharmaceutical production. **Key Advantages:** * **Human-like modifications**: Produces proteins with glycosylation patterns similar to human proteins * **Safety record**: Long history of use in approved therapeutic proteins * **Scalability**: Can be grown in large bioreactors for industrial production * **Stable expression**: Can create cell lines that consistently produce proteins **Best for:** * Complex therapeutic proteins * Antibodies and glycoproteins * Proteins requiring specific folding patterns ### HEK 293 (Human Embryonic Kidney) Cells HEK 293 cells are human-derived cells particularly valued for their ease of use and high transfection efficiency. **Key Advantages:** * **High transfection efficiency**: Can achieve nearly 100% transfection rates * **Human protein processing**: Native human post-translational modifications * **Versatile growth**: Can grow in adherent or suspension culture * **Rapid protein production**: Faster than CHO for transient expression **Best for:** * Viral vector production * Transient protein expression * Proteins requiring human-specific modifications [Learn more about expression in HEK 293 →](https://en.wikipedia.org/wiki/HEK_293_cells#Applications) ### Insect Cells Insect cell expression systems, typically using Sf9 or Sf21 cells with baculovirus vectors, offer a middle ground between bacterial and mammalian systems. **Key Advantages:** * **High expression levels**: Can achieve yields up to 500 mg/L * **Eukaryotic processing**: Proper protein folding and some post-translational modifications * **No biosafety concerns**: Baculoviruses don't infect mammals * **Multi-protein expression**: Can express protein complexes **Best for:** * Large proteins and protein complexes * Proteins requiring some glycosylation * Vaccine production (VLPs) * Structural biology applications [Learn more about expression in insect cells →](https://www.thermofisher.com/us/en/home/life-science/protein-biology/protein-biology-learning-center/protein-biology-resource-library/protein-expression-handbook/pex-handbook-insect-cell-based-protein-expression.html) ### Yeast Expression Systems Yeast combines the advantages of rapid microbial growth with eukaryotic protein processing capabilities. **Key Advantages:** * **Eukaryotic modifications**: Can perform glycosylation and proper folding * **Cost-effective**: Less expensive than mammalian systems * **High cell density**: Can achieve very high biomass in fermentation * **Established platforms**: Well-developed strains like S. cerevisiae and P. pastoris **Best for:** * Industrial enzyme production * Proteins requiring simple glycosylation * Large-scale protein production * Vaccine antigens [Learn more about expression in yeast →](https://en.wikipedia.org/wiki/Yeast_expression_platform) ## Choosing the Right Expression System The choice of expression system depends on several factors: Simple proteins → Bacterial systems Complex proteins → Mammalian systems No modifications → E. coli Glycosylation needed → CHO, HEK, or Insect cells Research scale → E. coli or HEK 293 Industrial scale → CHO or Yeast Rapid production → E. coli or transient HEK Stable production → CHO cell lines ## Summary Each protein expression system offers unique advantages. E. coli provides speed and simplicity for basic proteins, while mammalian systems like CHO and HEK 293 cells excel at producing complex therapeutic proteins. Insect cells and yeast offer intermediate solutions with good yields and some eukaryotic processing capabilities. The optimal choice depends on your specific protein requirements, scale, and intended application. # scFv Source: https://docs.adaptyvbio.com/wiki/proteins/scfv Minimal antibody fragment with variable domains linked by a peptide scFv (single-chain variable fragment) is the smallest functional antibody fragment, consisting of VH and VL domains connected by a flexible peptide linker. \~25-30 kDa Monovalent (1 binding site) Single polypeptide chain Bacterial expression ## Structure Linker length (typically 15-20 amino acids) is critical for proper folding and stability. * **VH domain** - Variable heavy * **VL domain** - Variable light * **Flexible linker** - Common: (Gly₄Ser)₃ ## Key Applications Easy library display and selection Good tissue penetration, low immunogenicity Building blocks for complex formats Ideal for applications requiring small size and single-gene expression. # VHH (Nanobodies) Source: https://docs.adaptyvbio.com/wiki/proteins/vhh Single-domain antibody fragment derived from camelids VHH fragments (nanobodies) are the smallest natural antigen-binding domains, derived from camelid heavy-chain-only antibodies. \~15 kDa (smallest) Camelids (llamas, camels) Exceptional heat/pH resistance Single domain, no light chain ## Unique Features VHH can access cryptic epitopes in protein cavities that larger antibodies cannot reach. * **Extended CDR3 loops** - Longer than conventional antibodies * **No light chain pairing** - Functions independently * **Refolding capability** - Can refold after denaturation Requires specialized discovery platforms (camelid immunization or synthetic libraries). ## Applications Excellent tissue penetration and low immunogenicity make VHH ideal for in vivo applications. Can be expressed inside cells for intracellular target studies. Stable under harsh conditions, ideal for robust assays. # Biolayer Interferometry (BLI) Source: https://docs.adaptyvbio.com/wiki/technologies/BLI Label-free optical technique for real-time protein binding measurements BLI measures real-time protein binding by detecting changes in light interference patterns when molecules bind to a sensor surface. Label-free optical detection Real-time kinetics Sub-nanomolar detection Designed proteins immobilized on biosensor tip using Twin-Strep-Tag [Target protein](/docs/experiment-setup/target-proteins) flows over sensor surface Binding causes detectable light interference shift Association and dissociation rates calculated ## Key Parameters BLI provides three critical binding parameters: k\_on (association), k\_off (dissociation), and K\_D (equilibrium constant). * **k\_on** - Association rate constant * **k\_off** - Dissociation rate constant * **K\_D** - Equilibrium dissociation constant (k\_off/k\_on) BLI sensorgram showing association and dissociation across a target concentration series ## How we use BLI at Adaptyv We use the **Gator Bio Pro** for BLI measurements. Our typical workflow involves: * **Protein immobilization**: User-designed proteins are expressed with a linker and Twin-Strep-Tag * **Target protein binding**: Biosensor is moved into solutions of the target protein at different concentrations * **Kinetic analysis**: Real-time binding measurements to determine association and dissociation kinetics This approach enables efficient characterization of binding interactions for designed proteins with high sensitivity. ## Related pages * [Binding](/docs/experiment-types/binding) * [Binding Data Package](/docs/experiment-setup/binding-data-package) # Surface Plasmon Resonance (SPR) Source: https://docs.adaptyvbio.com/wiki/technologies/SPR Label-free, real-time binding kinetics and affinity measurements SPR measures biomolecular interactions in real time without labels. Use it to quantify kon, koff, and KD across a broad affinity range. ## What it measures * Real-time association and dissociation to quantify kon, koff, and KD * Label-free readout on sensor chips SPR sensorgram showing association and dissociation across a target concentration series ## When to use * You need precise kinetics beyond endpoint binding * Benchmarking or mechanism studies ## How we use SPR at Adaptyv We use the **Carterra LSA XT** for high-throughput SPR measurements. Our typical workflow involves: * **Protein expression**: User-designed proteins are expressed with a linker and Twin-Strep-Tag * **Surface capture**: Tagged proteins are immobilized on the sensor chip surface * **Kinetic analysis**: Real-time binding measurements to determine kon, koff, and KD values This approach allows us to efficiently characterize binding interactions for designed proteins across multiple conditions. ## Related pages * [Binding](/docs/experiment-types/binding) * [BLI](/wiki/technologies/BLI) * [Construct & Tag Design](/wiki/technologies/construct-tag-design) * [Binding Data Package](/docs/experiment-setup/binding-data-package) # Affinity Tag Purification Source: https://docs.adaptyvbio.com/wiki/technologies/affinity-tag-purification High-throughput protein purification using engineered affinity tags for rapid isolation and concentration Affinity tag purification is a key step in our protein production workflow, enabling rapid, high-purity isolation of target proteins for downstream assays. Our platform uses two primary affinity tag systems optimized for different experimental requirements. For the full standard construct we append to every binder (tag layout, placement, and how it couples to SPR), see [Construct & Tag Design](/wiki/technologies/construct-tag-design). ## Supported Affinity Tags Our default purification tag due to its high affinity and specificity, enabling excellent yields and clean eluates. Highly interoperable with our BLI/SPR measurements. On demand, we can also work with other tags such as **His**, **Fc**, or lab‑specific alternatives. Tag choice depends on your protein and downstream requirements. ## Tag Positioning **C-terminal placement (default):** We use C-terminal tags for 90% of proteins because the tag only gets expressed if the entire protein gets expressed. This prevents purification of truncated proteins that could occur with N-terminal tags if protein expression stalls. **N-terminal placement (on request):** Available through the Foundry portal when needed, such as when the binding site is close to the C-terminus and might be affected by tag placement. All tags include a GS linker for proper spacing and minimal interference with protein function. ## Workflow Integration Purified proteins from this process are directly used in downstream assays including: * **Binding assays** (BLI, SPR) * **Structural analysis** * **Functional studies** * **Quality control** measurements Tag selection and positioning can be customized based on your specific protein and experimental requirements through the Foundry portal. # Capillary Electrophoresis (CE) Source: https://docs.adaptyvbio.com/wiki/technologies/capillary-electrophoresis Capillary electrophoresis for quantitative analysis of protein expression, purity, and heterogeneity Capillary electrophoresis (CE) provides high-resolution, label-free quantification of protein expression and purity in small volumes. We use CE (including CE-SDS and cIEF modes) to quantify expression levels, detect fragmentation/aggregation, and assess charge variants. ## How It Works Proteins are separated in a narrow capillary under an electric field by size (CE-SDS, denaturing) or by isoelectric point (cIEF, native-like). Eluting species are detected by on-capillary UV absorbance (typically 214/280 nm). Peak area is proportional to protein mass, enabling titer and purity quantification against standards. ## Applications Estimate expression titer from crude lysates or purified material via calibrated peak areas. Resolve monomer, fragments, and aggregates to quantify product quality. Characterize acidic/basic variants and batch-to-batch heterogeneity (cIEF). Compare expression outcomes across constructs, hosts, or conditions. ## Performance & Notes * Linear quant range with appropriate standards; low-µg/mL sensitivity in CE-SDS. * Compatible with small sample volumes (≤10–20 µL); moderate throughput. * Denaturing CE-SDS reports size distribution; cIEF reports charge isoforms. * Detergents/salts should match method; sample cleanup may be required for crude matrices. ## Integration CE complements split-GFP and dye-based assays by providing orthogonal, high-resolution quantification and quality attributes (purity, fragments, charge variants) in protein expression workflows. # Cell-Free Protein Expression Source: https://docs.adaptyvbio.com/wiki/technologies/cell-free-protein-expression High-throughput protein production using cell-free expression systems for rapid prototyping and functional studies Cell-free protein expression uses the molecular machinery components of cells for protein synthesis without requiring living cells. This allows for rapid protein expression, significantly reducing the time from DNA to functional protein. ## How It Works The cell-free system contains extracted cellular components—ribosomes, tRNAs, amino acids, and energy sources—reconstituted in a controlled environment. DNA templates are directly added to this system, which then transcribes and translates proteins within hours. ## Our System We use an E. coli-based cell-free system that has been optimized to handle disulfide bond-containing proteins. Our system has successfully expressed a wide range of protein formats including: * **scFvs** (single-chain variable fragments) * **Nanobodies** * **FABs** (antigen-binding fragments) * **De novo designed proteins** * **Various other protein formats** ## Key Benefits Protein production within hours instead of days, enabling faster design-build-test cycles. Optimized system components support proper folding of proteins requiring disulfide bonds. ## Applications Cell-free expression enables rapid prototyping for: * **Binding studies**: Direct use in BLI and SPR assays * **Protein screening**: Quick evaluation of multiple variants * **Functional characterization**: Immediate availability for downstream assays ## Integration with Other Technologies Expressed proteins integrate seamlessly with our analytical workflow: * **Affinity purification**: Direct capture using tagged proteins * **Binding assays**: Immediate use in binding studies * **Thermostability**: Direct input to nanoDSF analysis * **Quality control**: Real-time monitoring capabilities ## Frequently Asked Questions Adaptyv uses a **fully reconstituted, cell-free protein expression system** made from individually purified components of the *E. coli* transcription–translation machinery. This allows for **high control, low background**, and compatibility with sensitive or synthetic protein designs. Adaptyv bypasses the need for plasmid cloning by directly using **full-length double-stranded linear DNA (dsDNA)**, which is **ordered from external providers** and ready for immediate use in expression reactions. In some workflows, tag sequences may be appended in-house, and longer-term processes may involve assembling genes from fragments. **Our system includes:** * **Ribosomes** * **tRNAs and synthetases** * **Transcription and translation factors** * **T7 RNA polymerase** (for transcription) * **Nucleotides, amino acids, and energy sources** * **DsbC** (a disulfide bond isomerase) * **Oxidized and reduced glutathione** **Process:** * The DNA is transcribed into mRNA by T7 RNA polymerase * The mRNA is translated into protein by the ribosomes * Proteins are synthesized **within a few hours** Maximum yield is usually reached **within 4–6 hours**, though shorter reactions (e.g., 2–3 hours) are often sufficient for functional assays or screening purposes. **Typical yield:** 50-300 **µg/mL** for scFvs and 50-600 **µg/mL** for small de novo proteins. (Yield may vary based on sequence, folding, and template design). By using full-length dsDNA with the PURE system, Adaptyv accelerates the design-test-learn loop, making protein expression faster, cleaner, and more programmable. There are several advantages of cell-free systems in general, and "Pure"-type cell-free systems in particular: **1. Toxic protein expression** One can express proteins that are normally toxic to cells. In cell culture, if the protein damages cellular systems required for growth, cells die early and protein yield is very poor. In cell-free systems, as long as the protein doesn't interfere with the translation system, there's no problem. **2. Direct DNA addition** One can mix DNA directly with the translation mix - no need for cell transfection. Cell transfection requires cost, time, and has less than 100% efficiency. **3. No basal expression issues** No need for expression induction in cell-free systems. In cell culture, proteins take energy from cells, slowing growth. Therefore, expression must be heavily repressed during growth phase, then induced with inductor molecules. **4. Linear DNA compatibility** In "Pure" cell-free systems, linear DNA can be used instead of circular plasmids, since degrading enzymes are removed. This reduces cost and time for DNA preparation. **5. Consistent component ratios** In "Pure" systems, we mix purified components, so there's never component depletion, and ratios (energy sources, ribosomes) remain constant. This isn't true in live cell culture systems. Several factors can affect protein expression success: **1. Solubility issues** Some protein sequences tend to self-aggregate and precipitate out of solution, preventing sensor loading. This occurs when proteins have hydrophobic patches on the outside that cause them to stick together to avoid water exposure. **2. mRNA structure and interference** * **Secondary structures**: mRNA secondary structures can prevent proper translation by ribosomes * **Machinery interaction**: Some proteins may interact with cellular machinery, causing premature translation termination **Our optimization approach:** * Codon optimization software minimizes mRNA secondary structure stability * However, this may not be possible in all cases depending on amino acid sequence **Common problematic features:** * High hydrophobicity scores * Repetitive sequences * Unusual amino acid compositions * Large size (>50 kDa proteins may have lower success rates) Our team can provide sequence analysis and optimization recommendations to improve expression success rates for challenging proteins. **Non-standard amino acids:** * Our standard PURE system uses the 20 canonical amino acids * Non-canonical amino acid incorporation is possible but requires specialized protocols * Contact our team to discuss specific requirements for modified amino acids **Cyclic peptides:** * Traditional cyclic peptides require post-translational cyclization * Our cell-free system can potentially accommodate cyclization reactions * Requires custom development for specific cyclization chemistry **Alternative approaches:** * Disulfide-bonded peptides: Supported through DsbC and glutathione system * Split-intein mediated cyclization: Under development * Chemical cyclization post-expression: Possible with appropriate chemistry For non-standard amino acids or cyclic peptides, we recommend discussing your specific requirements with our technical team to determine feasibility and develop custom protocols. # Construct & Tag Design Source: https://docs.adaptyvbio.com/wiki/technologies/construct-tag-design The standard tag construct we append to every binder for expression, purification, and immobilization on the BLI or SPR sensor, and why it stays clear of the binding site. You submit your binder as a bare sequence (no tags needed). Before expression, we append a standard tag construct that handles three jobs at once: expression quantification, purification, and immobilization on the assay instrument. This page shows exactly what we add, where it goes, and how we keep it away from the binding interface. ## The standard construct By default we append the following to the C-terminus of your binder, connected by flexible GGGS linkers:
Your binder
your design
GGGS
split-GFP11
expression
GGGS
Twin-Strep-tag
purify + immobilize
**Full sequence appended to your protein** (GGGSGGGS linker, then the tag):
GGGSGGGSRDHMVLHEYVNAAGITGGGSGGGSGGSAWSHPQFEKGGGSGGGSGGSAWSHPQFEK
split-GFP11 Twin-Strep-tag (two Strep-tag II copies) unhighlighted = GGGS linkers
| Component | Sequence | Purpose | | - | - | - | | GGGS linkers | `GGGSGGGS…` | Flexible spacers that decouple the tag from the folded domain | | split-GFP11 | `RDHMVLHEYVNAAGIT` | Expression quantification via split-GFP complementation (not used for purification) | | Twin-Strep-tag | `GGSAWSHPQFEKGGGSGGGSGGSAWSHPQFEK` | Purification and immobilization handle (two tandem Strep-tag II joined by a GGGSGGGS linker) | The Twin-Strep-tag does double duty: it is how we purify the protein and how we capture it onto the sensor. On our platform, capture is the purification step. ## Why these tags * **Twin-Strep-tag:** a high-affinity, well-behaved handle for Strep-Tactin XT. We use it both to purify the binder and to immobilize it on the BLI or SPR sensor, so a single tag covers the whole workflow. * **split-GFP11:** a small fragment that reconstitutes fluorescence with a complementary GFP1-10 fragment, letting us quantify expression without a separate readout. See [Split-GFP quantification](/wiki/technologies/split-GFP) for the method. We do not cleave purification tags. Instead we choose placement (or follow your preference) so the tag stays clear of the binding site, which is what the structures below are for. ## Tag placement **C-terminal is the default.** In our hands it gives the most consistent expression across protein types. You can request N-terminal placement instead if the C-terminus is functionally important for your design; just flag it at submission. The construct is designed so the tag sits away from the binding interface regardless of scaffold. The predicted structures below show the tag position relative to the paratope across representative protein types. In each: binder green, target blue, and the C-terminal tag gold, extending away from the binding site. De novo binder against IL-7Ra with C-terminal tag extending away VHH nanobody against Nipah-G with C-terminal tag extending away scFv against EGFR with C-terminal tag extending away ## How the tag is used in the assay We measure binding kinetics by BLI on the Gator Bio Pro or SPR on the Carterra LSA XT. On both, the Twin-Strep-tag is the capture handle: it immobilizes your binder as the ligand on a Strep-Tactin surface (a biosensor tip for [BLI](/wiki/technologies/BLI), or the sensor chip for [SPR](/wiki/technologies/SPR)), while the target is delivered in solution as the analyte. 1. **Capture.** Your Twin-Strep-tagged binder is captured onto the Strep-Tactin surface. This capture step also serves as the purification, so no separate purification is required on our platform. 2. **Kinetics.** The target is presented in solution across a concentration series, and real-time association and dissociation yield kon, koff, and KD. ## See also * [Split-GFP quantification](/wiki/technologies/split-GFP): how we use the split-GFP11 fragment to quantify expression. * [Affinity Tag Purification](/wiki/technologies/affinity-tag-purification): the purification handle in more detail. * [BLI](/wiki/technologies/BLI) and [SPR](/wiki/technologies/SPR): the binding assays this construct is built for. # HPLC-SEC Source: https://docs.adaptyvbio.com/wiki/technologies/hplc-sec High-Performance Liquid Chromatography Size-Exclusion Chromatography for protein aggregation detection and quality control **Coming Soon Technology** HPLC-SEC is currently in development for our platform. This technology will be available for protein analysis services in the near future. HPLC-SEC (High-Performance Liquid Chromatography Size-Exclusion Chromatography) will be used for size exclusion chromatography to detect protein aggregation and provide quantification and quality control for expressed proteins. ## What We'll Measure Size-exclusion chromatography separates proteins based on their size as they pass through a porous column. Larger molecules (like protein aggregates) elute first, followed by smaller molecules in order of decreasing size. We'll use this to identify if proteins are forming aggregates, separate aggregated proteins from monomers, and quantify the percentage of aggregated vs. non-aggregated protein. ## Primary Applications Detect if proteins are clumping together and quantify aggregation levels over time. Verify protein purity after expression and ensure consistent protein production. ## Integration with Other Technologies HPLC-SEC will work alongside our existing analytical capabilities including nanoDSF for thermal stability correlation, BLI for binding activity assessment, and cell-free expression for comprehensive protein characterization. HPLC-SEC will be particularly valuable for quality control of expressed proteins, helping ensure that proteins maintain their intended structure and don't form aggregates that could affect experimental results. # nanoDSF Source: https://docs.adaptyvbio.com/wiki/technologies/nanodsf Nano Differential Scanning Fluorimetry for protein thermostability assessment and melting temperature determination nanoDSF (Nano Differential Scanning Fluorimetry) is used on our platform for thermostability assessment of proteins. This label-free technique measures melting temperatures by monitoring intrinsic fluorescence changes during thermal unfolding. ## How It Works Upon increasing temperature, the hydrophobic core of proteins unfolds, exposing aromatic amino acids (tryptophan and tyrosine) that produce fluorescent signals. The fluorescence intensity changes over time as the protein unfolds, and we take the first derivative of this signal to create a peak from which we can compute the melting temperature (Tm). nanoDSF melting curve with the 350 over 330 fluorescence ratio and its first derivative marking the melting temperature **Important Caveat:** This technique works best for proteins with a hydrophobic core containing aromatic amino acids. Some de novo mini binders might not have sufficient aromatic amino acids to produce a strong fluorescent signal. ## Temperature Range We can measure thermostability from room temperature to 95°C, providing comprehensive thermal profiles for protein characterization. ## Protein Types nanoDSF works well for: * **scFvs** (single-chain variable fragments) * **FAPs** (fluorogen-activating proteins) * **Nanobodies** * **Certain de novo designed proteins** * **Other proteins with sufficient aromatic amino acid content** ## Applications Determine baseline thermal stability and compare protein variants to identify the most stable candidates. Evaluate how different buffer conditions affect protein stability to optimize storage and experimental conditions. Thermostability measurements provide valuable insights into protein behavior and help optimize experimental conditions for downstream applications. Looking to run a thermostability assay? See the product page: Thermostability. # Quant-iT Protein Assay (Qubit) Source: https://docs.adaptyvbio.com/wiki/technologies/quant-it Fluorescent dye–based protein quantification for sensitive expression measurements The Quant-iT (Qubit) protein assay provides rapid, sensitive quantification of total protein using a fluorescence dye with minimal interference from common buffers. We use it for quick expression titer estimates in crude lysates and purified samples. ## How It Works A protein-selective fluorescent dye binds to proteins with high specificity. After mixing sample with working reagent and incubating briefly, fluorescence is measured on a fluorometer and converted to concentration using a standard curve. Signal is proportional to protein mass within the kit’s linear dynamic range. ## Applications Fast quantification of expression levels across constructs and conditions. Higher sensitivity and specificity than colorimetric assays in many buffers. Tolerates typical expression buffers; simple workflows and small volumes. Improves accuracy by matching dye response to the target protein class. ## Performance & Notes * Linear dynamic ranges depend on kit (e.g., HS vs BR); choose to match expected titer. * Minimal interference versus Bradford/BCA; some detergents/chaotropes still affect signal. * Requires standard curve each run; protein-to-dye response can vary across protein classes. ## Integration Quant-iT complements split-GFP and CE by enabling rapid, sensitive total-protein quantification to triage expression conditions before detailed purity/heterogeneity analyses. # Split GFP Quantification Source: https://docs.adaptyvbio.com/wiki/technologies/split-GFP How we quantify expression: a split-GFP11 fragment on your construct, a GFP1-10 detection reagent added after expression, and fluorescence read against a standard curve. Split-GFP quantification is how we measure expression for your designs. We append a split-GFP11 fragment to every construct, add the complementary GFP1-10 fragment as a reagent after expression, and read the resulting fluorescence against a standard curve. The concentration reported in your results comes directly from that fluorescence. ## What we append to your design Before expression, we add a two-part tag to your submitted sequence, joined by flexible GGGS linkers. Default placement is the C-terminus. 1. **split-GFP11**, for expression quantification. 2. **Twin-Strep-tag**, for purification and immobilization on the sensor. The split-GFP11 fragment sits next to the affinity tag: ```text theme={null} RDHMVLHEYVNAAGIT ``` See [Construct and tag design](/wiki/technologies/construct-tag-design) for the full appended sequence and tag placement. ## GFP11 versus GFP1-10 These are the two halves of the same fluorescent protein, but only one of them is part of your construct. | Fragment | Where it lives | Role | | - | - | - | | split-GFP11 | Appended to your protein | Expression handle, expressed with your design | | GFP1-10 | Added by us after expression | Detection reagent, supplied in excess | GFP1-10 is a reagent, not part of your construct. It never appears in the sequence you submit or in the protein we express. Only the GFP11 fragment is on your design. When GFP11 on the expressed protein meets GFP1-10 in solution, the two fragments reconstitute into functional, fluorescent GFP. Neither fragment fluoresces alone, so fluorescence is proportional to the amount of GFP11-tagged protein present. ## How the measurement works Your design is expressed with the split-GFP11 and Twin-Strep-tag construct attached. We add the GFP1-10 detection reagent in excess to the expressed material. Reconstituted GFP fluorescence is read in relative fluorescence units (RFU). RFU is converted to concentration using a standard curve built from known standards. The readout reflects **total soluble expression**, measured after expression. split-GFP standard curve: measured fluorescence against GFP11-tagged protein concentration, with a linear fit of y = 130.1x + 261 and R² = 0.994 over 2.5 to 25 µM ## Fluorescence is the direct measurement There are no intermediate absorbance or A280 readings behind the reported concentration. Fluorescence is read, the standard curve converts it, and that value is what appears in your results. We also do not run separate SDS-PAGE, SEC or A280 characterization on designs. Once expression is validated, designs go directly into the binding assay. ## Which formats carry the tag The split-GFP tag is added to all proteins **except Fabs and IgGs**. Oligomeric proteins are more sensitive to tag addition, which can affect their assembly, so we leave those formats untagged. An alternative expression quantification approach for Fabs and IgGs is in development. ## FAQ Directly from fluorescence. The GFP1-10 reagent is added after expression, reconstituted GFP fluorescence is read in RFU, and a standard curve of known standards converts that RFU value to concentration. There are no intermediate measurements between the fluorescence reading and the reported concentration: no absorbance step, no A280. No. We add the split-GFP tag to all proteins except Fabs and IgGs. Oligomeric proteins are more sensitive to tag addition, which can affect their assembly, so those formats are expressed without it. An alternative approach for Fabs and IgGs is in development. Yes. We do not cleave the tag between expression and binding, so the reported binding data is measured on the tagged protein. ## Related pages * [Construct and tag design](/wiki/technologies/construct-tag-design): the full tag we append, its sequence, and where it sits on your design. * [Expression](/docs/experiment-types/expression): what an expression run includes and what you receive.