---
title: "Verify a full assembly recipe"
method: POST
path: "/verify_assembly"
tags: ["Enzymes & cloning"]
---

# Verify a full assembly recipe

`POST /verify_assembly`

## Request

- Base URL: `https://seqbench.com/api/v1`
- URL: `https://seqbench.com/api/v1/verify_assembly`
- Auth: none required

Deterministic self-check: given the same method/parts cloning_simulate would use (restriction-ligation, Gibson, Golden Gate, LIC, SLIC or In-Fusion/CPEC — optionally deriving a part by in-silico PCR first), re-derive the expected WHOLE product and diff it against a claimed final sequence. Returns pass/fail plus the exact position and nature of any discrepancy — not an opinion, the same deterministic simulation SeqBench already runs, run a second time as a check. A recipe that can give more than one molecule is checked against ALL of them and `matchedCandidate` names the one the claim matched: a non-directional ligation really does put the insert in both ways round (half the plate carries each), a vector cut more than twice offers more than one backbone, and a Gibson junction whose fragments already share terminal sequence has two honest readings (one homology arm, or a tandem repeat present twice). See verify_construct for a narrower, insert-only check that doesn't require declaring the vector/enzymes/method.

## Request body

- object
  - `method` 'restriction' | 'gibson' | 'goldengate' | 'lic' | 'slic' | 'infusion', required: Assembly method used. restriction/gibson/goldengate are the primer-and-enzyme methods; lic and slic re-run the T4-polymerase chew-back (sequence-defined and time-stopped respectively) and infusion is In-Fusion/CPEC. Anything else is refused rather than substituted — see the note on "topo".
  - `claimedConstruct` string, required: The sequence you claim you ended up with.
  - `circular` boolean: Treat the product/claimed construct as circular (most plasmids are).
  - `coding` boolean: Report amino-acid effects of any mismatch, assuming claimedConstruct is (or contains) a coding sequence.
  - `frameStart` integer: 1-based reading-frame start on claimedConstruct, used when coding is true.
  - `vector` string: Vector sequence (restriction and lic methods; for lic, the LINEARIZED vector). Omit if vectorPcr is given.
  - `vectorPcr` object: Derive the vector by PCR instead: {template, forwardPrimer, reversePrimer, maxMismatches? (0-10), circular?}.
  - `insert` string: Insert sequence (restriction and lic methods). Omit if insertPcr is given.
  - `insertPcr` object: Derive the insert by PCR instead: {template, forwardPrimer, reversePrimer, maxMismatches? (0-10), circular?}.
  - `enzyme5` string: Insert 5′ enzyme (restriction method).
  - `enzyme3` string: Insert 3′ enzyme (restriction method).
  - `vectorEnzyme5` string: Vector 5′ enzyme (restriction method); defaults to enzyme5. Set a different, compatible enzyme (e.g. BglII for a BamHI insert) to verify heterologous-overhang cloning.
  - `vectorEnzyme3` string: Vector 3′ enzyme (restriction method); defaults to enzyme3.
  - `dephosphorylateVector` boolean: The linearized vector was CIP/rSAP-dephosphorylated (restriction method). Affects the self-ligation background warnings, not the product.
  - `fragments` string[]: Fragments (5′→3′), assembled head-to-tail (gibson/goldengate/slic/infusion). BARE parts only — for gibson do NOT include the homology arms, which are added by the assembly primers and merged (so the product is fragment1+…+fragmentN). The convention is the OPPOSITE for slic and infusion: there the homology must already BE on the fragments (it arrived on the PCR primer tails), and infusion derives the ORDER from those homologies, so the order listed here is ignored. Use "" as a placeholder for any fragment supplied instead via the matching fragmentPcrs[i].
  - `fragmentPcrs` object[]: Parallel to fragments, same length: null (or omit) to use fragments[i] directly, or a PCR spec {template, forwardPrimer, reversePrimer, maxMismatches? (0-10), circular?} to derive that fragment instead.
  - `names` string[]: Optional labels for each fragment.
  - `overlapLen` integer: Gibson homology-arm length (bp) that the assembly PRIMERS add at each junction. Since the fragments themselves must not carry their arms, this describes the junction/primer design only — it does not change the predicted product length or the verdict.
  - `mergePreAddedArms` boolean: Gibson only. When two fragments already share terminal sequence, count that share ONCE (the default — the fragments already carry their arm) or set false to concatenate it twice, which is the right reading when the shared block is a genuine tandem repeat. You should rarely need this: the check tries BOTH readings and reports which one matched in `matchedCandidate`. Setting it restricts the check to one.
  - `armTmTarget` number: Target annealing Tm (°C) for primer arms.
  - `enzyme` string: Type IIS enzyme for Golden Gate — one of BsaI, BbsI, Esp3I (BsmBI); "BsmBI" also resolves to Esp3I, and NEB's variant names (BsaI-HFv2, BbsI-HF, BsmBI-v2) fold to the parent enzyme. Any other name fails the verification outright rather than being substituted.
  - `vectorNucleotide` 'A' | 'C' | 'G' | 'T': lic method: the single dNTP the VECTOR's chew-back was run with (T for dTTP…). Required — T4 pol's exonuclease stops at the first occurrence of this base reading inward from each 3′ end, so there is no product to check against without it.
  - `insertNucleotide` 'A' | 'C' | 'G' | 'T': lic method: the single dNTP the INSERT's chew-back was run with. Normally the COMPLEMENT of vectorNucleotide (the classic pair is dTTP on the vector, dATP on the insert).
  - `chewBackLen` integer: slic method: nucleotides removed from each 3′ end. A SLIC chew-back has no dNTP to arrest it and is stopped by time, so this is an input rather than a property of the sequence. 0 (default) models the intended reaction — chewed to the full homology and no further.
  - `homologyLen` integer: infusion method: terminal homology required at every junction, in bp. At least 15 — the junction is annealed and extended by a polymerase with no exonuclease to widen it and no ligase to seal it, so a shorter overlap is a different chemistry rather than a weaker version of this one.

## Response `200`

Tool ran successfully.

- SuccessResponse: Standard success envelope returned by every single-tool call.
  - `ok` unknown, required
  - `tool` string, required: The tool slug that ran.
  - `result` object, required: Tool-specific output object. Its shape depends on the tool — call `GET /{tool}` or see the docs for each tool's fields.
  - `gate` GateResult
    - `pass` boolean, required: True if and only if every hard check passed.
    - `checks` GateCheck[], required
      - `id` string, required
      - `label` string, required
      - `severity` 'hard' | 'soft', required
      - `pass` boolean, required
      - `message` string, required
      - `value` number
      - `threshold` string
    - `notChecked` string[], required: Honest list of what this gate does NOT verify.
  - `provenance` Provenance, required
    - `apiVersion` string, required
    - `tool` union, required: Tool slug, or an array of slugs (one per step) for a workflow.
      - string
      - string[]
    - `generatedAt` string, date-time, required: ISO 8601 timestamp of when the result was generated.

## Other responses

- `400`: Invalid argument or the tool could not run.
- `404`: Unknown tool.
- `429`: Rate limited (metered tools only). Body carries code `rate_limited` and retryable `true`; honor the Retry-After header.
- `503`: A metered tool is momentarily at capacity. The identical request should succeed after Retry-After; body carries code `upstream_unavailable`.

---

[API](https://skmtc.dev/seqbench/apis/seqbench-api.md) · [All operations](https://skmtc.dev/seqbench/apis/seqbench-api/llms.txt) · [OpenAPI document](https://skmtc.dev/seqbench/apis/seqbench-api/revisions/132575216865?raw)