Documentation

Open api.nexio.bio

Mitochondria API · OpenAPI 3.0.3 · v1.0.0

Overview

Purpose: DNA cloning and primer-design microservice for BioNexio workflows—restriction cloning, PCR cloning, Gibson overlap assembly, simple PCR primers, backbone linearization, restriction-site lookup, and codon optimization.

Base path: Routes are mounted under the deployment `PREFIX` from environment (often `/api`). Example: `POST {server}{prefix}/primers/simple`.

Authentication: Every endpoint except `/`, static assets, and Swagger UI requires `Authorization: Bearer <api-key>`. Missing or invalid keys return 403 JSON (not 401).

API keys and usage quotas: Some deployments distinguish admin keys (environment configuration) from standard keys stored in the usage database. Admin keys are not subject to token quotas or stored-oligo caps. Standard keys have per–UTC-day and per–UTC-month token budgets and a stored-oligo cap; each successful operation consumes a route-specific token cost. When a token budget would be exceeded, the server returns 403 with `error: Payment Required` and a quota message. GET `/quota/limits` returns the current caps and usage without consuming tokens. POST `/admin/api-keys` creates new standard keys and requires an admin bearer key.

Stored oligos: `GET`/`POST /oligos` and `GET`/`DELETE /oligos/{id}` persist DNA and optional GenBank under the API key. Compute bodies accept oligo objects (`id` loads; `seq` is inline; `id` with `seq`/`genbank` saves). Deprecated string fields remain valid but must not be sent together with the oligo sibling (422). `options.overwrite` replaces an existing id; `options.save_results` stores DNA/GenBank outputs and returns a handle `{ id, type, path }` instead of inline results. Exceeding the stored-oligo cap is 403 with `error: Forbidden` (not Payment Required). An existing id with different `seq` or `genbank` and overwrite false is 409; repeating the same `id` with the same `seq` (and the same `genbank` when sent) succeeds without replacing the row.

Vector catalog: `GET /catalog/vectors` lists curated backbones (currently `pcDNA3.1`). `GET /catalog/vectors/{name}` returns the full backbone (`seq`, `genbank`, MCS bounds, circular topology). Unknown names are 404. The catalog is read-only; persist a copy with `POST /oligos` if you need it under your API key.

Success shape: HTTP 200 bodies are JSON objects with `"status": "success"` and a `"results"` field (object, array, or string depending on the operation). Do not expect `"success": true` on 200 responses.

Errors: 400 invalid JSON or empty body; 422 validation / business rules (`message`, `success: false`, often `errors`); 500 unhandled or processing failures. Clients and AI agents should read `message` and optional `errors` for actionable detail.

Consumers: Descriptions are written for programmatic clients and LLM agents: field semantics, defaults, and edge cases (e.g. linear vs circular backbone) are stated explicitly.

Servers

  • https://api.nexio.bioProduction (HTTPS; path may match deployed PREFIX)
  • http://127.0.0.1:5000Local development (default port 5000)

Authentication

  • bearerAuthhttp · bearer

    API key issued for Mitochondria / Nucleus integration (value is not a JWT).

gibson_cloning4 operations

Gibson overlap primers and vector linearization candidates (Type IIP in MCS)

POST/cloning/gibson/primersGibson assembly primers (overlap + annealing)

operationId gibson_cloning_primers

Description

Designs forward/reverse primers for an insert: overlap regions are taken from `start_overlap_seq` / `end_overlap_seq` templates (extended until overlap Tm target), combined with annealing regions designed to `primer_tm`.

Overlaps or backbone: Provide both overlap templates, or omit both and supply `backbone` plus `restrictase`. When both overlap templates are present they are used, even if a backbone is also sent. Homology templates from `backbone` + `restrictase` come from a single MCS cut of a circular backbone. One overlap without the other, or neither a complete overlap pair nor backbone+restrictase, returns 422.

Insert: An `insert` oligo object.

Options: `primer_tm`, `overlap_size`, and `overlap_tm` are required. `overlap_size` is a minimum overlap length in bp (integer ≥ 1). `add_kozak` (default false) designs the forward annealing region against `GCCACC` immediately 5′ of the insert; the insert sequence must start with ATG. `overwrite` applies when saving an oligo input. This route does not persist primer outputs.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "end_overlap_seq": {
            "allOf": [
              {
                "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
              }
            ],
            "description": "Template for the 3' overlap."
          },
          "insert": {
            "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
          },
          "options": {
            "properties": {
              "add_kozak": {
                "default": false,
                "description": "When true, the forward annealing region is designed against GCCACC immediately 5′ of the insert. The insert sequence must start with ATG.\n",
                "type": "boolean"
              },
              "overlap_size": {
                "description": "Minimum overlap length (bp); actual overlap may grow to meet `overlap_tm`.",
                "example": 25,
                "minimum": 1,
                "type": "integer"
              },
              "overlap_tm": {
                "description": "Target duplex Tm (°C) applied when lengthening homology tails: overlap size grows until a sliding nearest-neighbour estimate reaches this target with simpler ion modelling than the primer melting_temperature fields (those use the fuller mixed-ion recipe on the insert annealing segment only—not the overlap).\n",
                "type": "integer"
              },
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "primer_tm": {
                "description": "Target Tm (°C) for the annealing portion of the primer.",
                "type": "integer"
              }
            },
            "required": [
              "primer_tm",
              "overlap_size",
              "overlap_tm"
            ],
            "type": "object"
          },
          "restrictase": {
            "allOf": [
              {
                "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
              }
            ],
            "description": "Enzyme used to linearize a circular backbone at a unique MCS site when overlap templates are omitted.\n"
          },
          "start_overlap_seq": {
            "allOf": [
              {
                "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
              }
            ],
            "description": "Template for the 5' overlap (typically vector-adjacent homology); longer than final overlap."
          }
        },
        "required": [
          "insert",
          "options"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "forward": {
                  "description": "One Gibson assembly primer: overlap (homology) region plus annealing region, full primer sequence, Tm of the annealing part, and ΔG metrics for the full primer (hairpin and homodimer components plus their minimum).\n",
                  "properties": {
                    "annealing_sequence": {
                      "allOf": [
                        {
                          "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
                        }
                      ],
                      "description": "Insert-specific annealing region (designed to target Tm)."
                    },
                    "full_seq": {
                      "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
                    },
                    "gibbs_free_energy": {
                      "allOf": [
                        {
                          "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/gibbs_free_energy"
                        }
                      ],
                      "description": "Minimum of hairpin and homodimer ΔG for the full primer (kcal/mol)."
                    },
                    "hairpin_gibbs_free_energy": {
                      "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/hairpin_gibbs_free_energy"
                    },
                    "homodimer_gibbs_free_energy": {
                      "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/homodimer_gibbs_free_energy"
                    },
                    "melting_temperature": {
                      "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/melting_temperature"
                    },
                    "overlap": {
                      "allOf": [
                        {
                          "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
                        }
                      ],
                      "description": "Homology overhang taken from the provided overlap template."
                    }
                  },
                  "required": [
                    "annealing_sequence",
                    "overlap",
                    "full_seq",
                    "melting_temperature",
                    "hairpin_gibbs_free_energy",
                    "homodimer_gibbs_free_energy",
                    "gibbs_free_energy"
                  ],
                  "type": "object"
                },
                "reverse": {
                  "$ref": "#/paths/~1cloning~1gibson~1primers/post/responses/200/content/application~1json/schema/properties/results/properties/forward"
                }
              },
              "required": [
                "forward",
                "reverse"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Forward and reverse Gibson primers (full sequences include overlaps)."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/cloning/gibson/restrictionCandidate Type IIP enzymes to linearize a circular vector (Gibson prep)

operationId gibson_cloning_restrictases

Description

Lists Type IIP enzymes from the supported catalog (blunt or sticky) that cut exactly once in the backbone and whose site lies in the MCS (`mcs_start`…`mcs_end`). Intended for choosing a linearization cut before overlap assembly—not for in vitro Gibson mastermix conditions.

Linear backbones: Returns [] (no circular MCS).

Shape: Same as `/cloning/pcr/restriction`—flat `{ name, position, recognition_site }[]`, not `restriction_part_pair`.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          }
        },
        "required": [
          "backbone"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "items": {
                "$ref": "#/paths/~1cloning~1pcr~1restriction/post/responses/200/content/application~1json/schema/properties/results/items"
              },
              "type": "array"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Sorted candidate enzymes with 1-based cut positions."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
GET/cloning/gibson/restriction/supported_restrictasesSupported Type IIP enzymes (sticky or blunt) for Gibson MCS linearization candidates

operationId gibson_cloning_supported_restrictases_get

Description

Alphabetical list of enzyme names from the curated Type IIP catalog (sticky or blunt) used when proposing single-cut vector linearization sites for `/cloning/gibson/restriction`. Names match the catalog used elsewhere; inclusion does not imply cutting a given backbone.

Authentication: Bearer required.

No request body. Empty GET request.

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "description": "Restriction enzyme identifiers, ascending lexicographic order.",
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Sorted unique enzyme names."
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/cloning/gibson/resultAssemble a circular Gibson plasmid as GenBank

operationId gibson_cloning_result

Description

Joins a circular backbone and a single insert amplified with Gibson primers, and returns a circular GenBank record.

Assembly model: The backbone is linearized by one unique cut of `restrictase` inside the MCS (supported restriction enzyme catalog). The homology arms carried by the primers are *shared* with the backbone ends, never duplicated, so the product is the linearized backbone followed by the amplified insert.

Primers: `forward_primer_full_seq` and `reverse_primer_full_seq` are the full primers as returned by `/cloning/gibson/primers` (overlap tail plus annealing region). Each primer is verified before assembly: the forward primer must anneal to the insert start and its 5′ tail must match the backbone end at the cut; the reverse primer must anneal to the insert end and its 5′ tail must match the backbone start at the cut. Primers failing either check are rejected rather than blunt-joined.

Backbone: must be circular and carry a GenBank record (`backbone.genbank`, or a stored backbone that has one) so the construct can be annotated; its features outside the cut are copied onto the product. Features straddling the cut are dropped. A backbone without a GenBank record is rejected.

Annotations: the insert is annotated with `insert_name` (default: the insert id) and feature type `insert_type` (default CDS; a CDS in frame from ATG also gets a translation). Both primer footprints are annotated.

Options: `options.add_kozak` (default false) must match how the primers were designed — when true, `GCCACC` is placed immediately 5′ of an insert that must start with ATG.

Output: 200 `results` is the full circular GenBank file as a string when `options.save_results` is false (including `LOCUS` and `//`). When `options.save_results` is true the construct is stored (`type` construct) and `results` is a handle.

Validation: Empty `construct_name`, linear backbones, enzymes that do not cut the backbone exactly once, missing insert sequences, primers without insert annealing or backbone homology, and a GenBank record whose length differs from the backbone sequence are rejected.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "construct_name": {
            "description": "Locus / construct name for the output record.",
            "example": "pcDNA31_KRAS",
            "minLength": 1,
            "type": "string"
          },
          "forward_primer_full_seq": {
            "allOf": [
              {
                "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
              }
            ],
            "description": "Full forward Gibson primer (homology tail plus annealing region)."
          },
          "insert": {
            "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
          },
          "insert_name": {
            "description": "Label for the insert feature; defaults to the insert name or id.",
            "example": "KRAS",
            "nullable": true,
            "type": "string"
          },
          "insert_type": {
            "default": "CDS",
            "description": "GenBank feature type for the insert (for example CDS or gene).",
            "type": "string"
          },
          "options": {
            "description": "Optional assembly and storage flags; defaults apply when omitted.",
            "properties": {
              "add_kozak": {
                "default": false,
                "description": "Must match the primer design: when true, GCCACC is assembled immediately 5′ of the insert, which must start with ATG.\n",
                "type": "boolean"
              },
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          },
          "restrictase": {
            "allOf": [
              {
                "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
              }
            ],
            "description": "Enzyme cutting the circular backbone exactly once inside the MCS."
          },
          "reverse_primer_full_seq": {
            "allOf": [
              {
                "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
              }
            ],
            "description": "Full reverse Gibson primer (homology tail plus annealing region)."
          }
        },
        "required": [
          "backbone",
          "insert",
          "restrictase",
          "construct_name",
          "forward_primer_full_seq",
          "reverse_primer_full_seq"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "oneOf": [
                {
                  "description": "Full circular GenBank record text after assembly and annotations.",
                  "type": "string"
                },
                {
                  "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1"
                }
              ]
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Circular GenBank text of the assembled construct, or a stored-oligo handle when `options.save_results` is true.\n"
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
golden_gate_cloning5 operations

Golden Gate Type IIS assembly planning, cassette detection, enzyme selection, and insert primers

POST/cloning/golden_gate/cassetteDetect a Type IIS cassette in the backbone MCS

operationId golden_gate_cassette_detect

Description

Checks whether the backbone contains a Golden Gate cassette: exactly two sites of the same Type IIS enzyme on the whole molecule, both inside the MCS (`mcs_start`…`mcs_end`), with opposing inward-facing arms. Two inward geometries are accepted for the dropped arc: forward then reverse (recognition motifs remain on the kept backbone) and reverse then forward (recognition motifs sit inside the dropout and are removed with the stuffer). Extra sites anywhere on the whole molecule — including outside the MCS or spanning a circular origin — invalidate that enzyme (no cassette). Two sites in the same orientation are not a cassette. When the MCS is the whole circular molecule, the dropout (stuffer) is the shorter clockwise arc between the two cuts. Only enzymes from the supported enzyme catalog are considered.

Output: `has_cassette` (boolean), `enzyme` (primary catalog name or null), `enzymes` (isoschizomer names for that primary, or empty), `positions` (1-based cut positions of the two arms), `recognition_sites` (motifs from the backbone at each arm), and `overhangs` (5′ top-strand sticky sequences at each cut, clockwise on the kept backbone ends).

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          }
        },
        "required": [
          "backbone"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "enzyme": {
                  "nullable": true,
                  "type": "string"
                },
                "enzymes": {
                  "description": "Isoschizomer names for `enzyme` from the supported enzyme catalog, or empty.",
                  "items": {
                    "type": "string"
                  },
                  "type": "array"
                },
                "has_cassette": {
                  "type": "boolean"
                },
                "overhangs": {
                  "description": "5′ top-strand sticky sequences at each cut (length of the enzyme overhang), clockwise on the kept backbone ends. Empty when `has_cassette` is false.\n",
                  "items": {
                    "type": "string"
                  },
                  "type": "array"
                },
                "positions": {
                  "items": {
                    "type": "integer"
                  },
                  "type": "array"
                },
                "recognition_sites": {
                  "description": "Recognition motifs on the backbone at each entry in `positions`.",
                  "items": {
                    "type": "string"
                  },
                  "type": "array"
                }
              },
              "required": [
                "has_cassette",
                "positions",
                "overhangs"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Cassette detection result."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/cloning/golden_gate/primersDesign Golden Gate Type IIS primers for ordered inserts

operationId golden_gate_cloning_primers

Description

Designs forward and reverse primers for each insert so Type IIS digestion produces ordered fusion overhangs that assemble into a cassette backbone. Insert array order is assembly order (clockwise).

Cassette: The backbone MCS must contain an inward cassette for `restrictase` (supported enzyme catalog primary name or a known isoschizomer, normalized to the primary). Cassette left and right fusion sites are taken from the backbone and are never client-overridable.

Hybrid overhangs: Optional `internal_overhangs` pins fusion sites between inserts. Length must be `len(inserts) - 1` when provided. Each entry is a sticky sequence to pin or `null` to auto-assign. Omit or pass `[]` when there is one insert. Pinned sites must be DNA bases A, C, G, T only, match the enzyme sticky-end length, be non-palindromic (not equal to their reverse complement), unique, and not equal to cassette fusion sites. Unpinned internals are assigned from the remaining unique non-palindromic catalog for that sticky-end length.

Primer chemistry: Each oligo is 5′ pad (minimum 4 bp) + recognition motif + spacer to the cut + fusion overhang + annealing. Reverse primers carry the reverse-complement of that end’s fusion site. Annealing is designed with the same simple-primer step as `/cloning/restriction/primers_combined`. Returned `melting_temperature` is from the annealing region only.

Validation: Inserts max 10. If `options.min_tm` is set, it must be strictly between 30 and 100 °C; omit or null for the same default as `/primers/simple` (60 °C). `min_length` is 15–35 bp (default 18). Inserts that still contain the enzyme recognition site are rejected (codon-optimize first). Missing cassette for the enzyme is rejected. `overwrite` applies when saving oligo inputs. This route does not persist primer outputs.

Output: `restrictase` (primary name); `junctions` (`len(inserts) + 1` entries, clockwise: cassette-left, internals, cassette-right) with `overhang`, `source` (`cassette_left` | `assigned` | `pinned` | `cassette_right`), and `left_part_id` / `right_part_id`; `parts` one per insert with `insert_id`, restriction primers, and PCR product (`full_seq` amplicon with Type IIS flanks; `restricted_seq` is insert plus the two fusion overhangs with recognition sites removed).

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "inserts": {
            "description": "Ordered inserts (assembly order).",
            "items": {
              "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
            },
            "maxItems": 10,
            "minItems": 1,
            "type": "array"
          },
          "internal_overhangs": {
            "description": "Hybrid pins for junctions between inserts (length `len(inserts)-1`). Each value is a fusion site to pin or null to assign.\n",
            "items": {
              "nullable": true,
              "type": "string"
            },
            "nullable": true,
            "type": "array"
          },
          "options": {
            "description": "Optional; defaults apply when omitted or empty.",
            "properties": {
              "min_length": {
                "default": 18,
                "description": "Minimum annealing length (bp) for the internal simple-primer step.",
                "maximum": 35,
                "minimum": 15,
                "type": "integer"
              },
              "min_tm": {
                "description": "Target Tm (°C) for the internal simple-primer step; must be in (30, 100) if set. Omit or null for default 60 °C.\n",
                "format": "double",
                "nullable": true,
                "type": "number"
              },
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              }
            },
            "type": "object"
          },
          "restrictase": {
            "allOf": [
              {
                "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
              }
            ],
            "description": "Type IIS enzyme (catalog primary name or isoschizomer)."
          }
        },
        "required": [
          "backbone",
          "inserts",
          "restrictase"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "junctions": {
                  "items": {
                    "properties": {
                      "left_part_id": {
                        "type": "string"
                      },
                      "overhang": {
                        "description": "Fusion sticky sequence (5′ top strand).",
                        "type": "string"
                      },
                      "right_part_id": {
                        "type": "string"
                      },
                      "source": {
                        "enum": [
                          "cassette_left",
                          "assigned",
                          "pinned",
                          "cassette_right"
                        ],
                        "type": "string"
                      }
                    },
                    "required": [
                      "overhang",
                      "source",
                      "left_part_id",
                      "right_part_id"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "parts": {
                  "items": {
                    "properties": {
                      "forward": {
                        "$ref": "#/paths/~1cloning~1restriction~1primers/post/responses/200/content/application~1json/schema/properties/results/properties/forward"
                      },
                      "insert_id": {
                        "type": "string"
                      },
                      "products": {
                        "$ref": "#/paths/~1cloning~1restriction~1primers/post/responses/200/content/application~1json/schema/properties/results/properties/products"
                      },
                      "reverse": {
                        "$ref": "#/paths/~1cloning~1restriction~1primers/post/responses/200/content/application~1json/schema/properties/results/properties/forward"
                      }
                    },
                    "required": [
                      "insert_id",
                      "forward",
                      "reverse",
                      "products"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "restrictase": {
                  "description": "Primary catalog name after isoschizomer normalization.",
                  "type": "string"
                }
              },
              "required": [
                "restrictase",
                "junctions",
                "parts"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Ordered insert primers, fusion junctions, and predicted PCR products."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/cloning/golden_gate/restrictionList compatible Type IIS enzymes for Golden Gate assembly

operationId golden_gate_cloning_restrictases

Description

Evaluates backbone and inserts for Type IIS enzymes from the supported enzyme catalog that are suitable for Golden Gate cloning. Flags parts that need codon optimization or backbone engineering when a cassette is missing or an insert contains the cassette site.

Cassette backbones: When the MCS contains a Type IIS cassette (two inward-facing arms of the same enzyme), the cassette enzyme is selected if inserts lack that recognition site. Both arm positions, recognition motifs, and fusion overhangs are returned. `position` and `recognition_site` repeat the left arm. Inserts that contain the site are listed in `optimize` with `preference` `backbone` (insert recoding).

Non-cassette backbones: Returns insert-safe enzymes from the supported catalog with `preference` `inserts` and the backbone id in `optimize`, indicating cassette engineering is required on the vector. Positions and overhangs are empty.

Preferred restrictases: Optional list reorders matching enzymes to the front of the results; it does not exclude other compatible enzymes. Unknown names are rejected.

Output: Array of `{ name, position, recognition_site, positions, recognition_sites, overhangs, preference, optimize }` where `positions`, `recognition_sites`, and `overhangs` describe both cassette arms when present, and `optimize` lists part ids needing recoding or backbone changes when no direct match exists.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "inserts": {
            "items": {
              "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
            },
            "maxItems": 10,
            "type": "array"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          },
          "preferred_restrictases": {
            "items": {
              "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
            },
            "type": "array"
          }
        },
        "required": [
          "backbone",
          "inserts"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "items": {
                "properties": {
                  "name": {
                    "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
                  },
                  "optimize": {
                    "description": "Part ids (backbone or insert) that need recoding or redesign for this enzyme.",
                    "items": {
                      "type": "string"
                    },
                    "type": "array"
                  },
                  "overhangs": {
                    "description": "5′ top-strand sticky sequences at each cassette cut (fusion overhangs). Empty when no cassette is reported.\n",
                    "items": {
                      "type": "string"
                    },
                    "type": "array"
                  },
                  "position": {
                    "description": "1-based cut position of the left cassette arm on the backbone forward strand. Same as `positions[0]` when a cassette is present; null otherwise.\n",
                    "format": "int32",
                    "minimum": 1,
                    "nullable": true,
                    "type": "integer"
                  },
                  "positions": {
                    "description": "1-based cut positions of both cassette arms when a cassette is present; empty otherwise.\n",
                    "items": {
                      "format": "int32",
                      "minimum": 1,
                      "type": "integer"
                    },
                    "type": "array"
                  },
                  "preference": {
                    "default": "backbone",
                    "description": "Which part type should be engineered when optimization is required.",
                    "enum": [
                      "backbone",
                      "inserts"
                    ],
                    "type": "string"
                  },
                  "recognition_site": {
                    "description": "Recognition motif as it appears on the backbone at the left cassette arm (including variable bases resolved from the target). Same as `recognition_sites[0]` when a cassette is present; null otherwise.\n",
                    "nullable": true,
                    "type": "string"
                  },
                  "recognition_sites": {
                    "description": "Recognition motifs on the backbone at each entry in `positions`. Empty when no cassette is reported.\n",
                    "items": {
                      "type": "string"
                    },
                    "type": "array"
                  }
                },
                "required": [
                  "name"
                ],
                "type": "object"
              },
              "type": "array"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Compatible Type IIS enzymes and optimization hints."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
GET/cloning/golden_gate/restriction/supported_restrictasesSupported Type IIS enzymes for Golden Gate cloning

operationId golden_gate_cloning_supported_restrictases_get

Description

Alphabetical list of primary Type IIS enzyme names from the curated Golden Gate catalog used for cassette detection and assembly planning. The list does not include every Type IIS enzyme, and inclusion does not imply the enzyme cuts a particular sequence.

Authentication: Bearer required (same as other cloning routes).

No request body: Empty GET request.

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "description": "Restriction enzyme identifiers, ascending lexicographic order.",
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Sorted unique enzyme names."
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/cloning/golden_gate/resultAssemble a circular Golden Gate plasmid as GenBank

operationId golden_gate_cloning_result

Description

Ligates a destination backbone with ordered PCR products using one Type IIS enzyme and returns a circular GenBank record. PCR product array order is assembly order (clockwise).

Cassette: The backbone must be circular and must contain an inward cassette for `restrictase` (supported enzyme catalog primary name or a known isoschizomer, normalized to the primary). Cassette fusion sites are taken from the backbone.

PCR products: Each product must be the Type IIS-flanked amplicon (as returned by `/cloning/golden_gate/primers` in `parts[].products.full_seq`). After digestion, sticky ends must match cassette left, then successive insert–insert fusions, then cassette right. Products that do not have exactly two cut sites for the enzyme, or whose overhangs do not match in the given order, are rejected.

Optional annotations: `backbone.genbank` is a complete GenBank record for the destination backbone. When present, features outside the dropped cassette span are copied onto the product. `insert_features` optionally names and types insert annotations by PCR product `id` (default feature type CDS; default label is the product id).

Output: 200 `results` is the full circular GenBank file as a string when `save_results` is false (not JSON-wrapped features), including `LOCUS` and `//`. When `options.save_results` is true, the construct is stored (`type` construct) and `results` is a handle. Remaining Type IIS recognition sites follow cassette geometry — destination cassettes (reverse then forward, motifs inside the dropout) leave none; part-entry cassettes (forward then reverse, motifs on the kept backbone) keep backbone recognition. Fusion scars are annotated.

Validation: Empty `construct_name` is rejected. Unknown enzyme names, missing cassette for the enzyme, linear backbones, empty PCR product lists, and overhang or cut-count mismatches are rejected.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "construct_name": {
            "description": "Locus / construct name for the output record.",
            "example": "pGG_test",
            "minLength": 1,
            "type": "string"
          },
          "insert_features": {
            "description": "Optional insert annotation overrides keyed by PCR product id.",
            "items": {
              "properties": {
                "id": {
                  "description": "PCR product id to annotate.",
                  "type": "string"
                },
                "name": {
                  "description": "Feature label; defaults to the product id.",
                  "nullable": true,
                  "type": "string"
                },
                "type": {
                  "default": "CDS",
                  "description": "GenBank feature type (for example CDS or gene).",
                  "type": "string"
                }
              },
              "required": [
                "id"
              ],
              "type": "object"
            },
            "nullable": true,
            "type": "array"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          },
          "pcr_products": {
            "description": "Ordered Type IIS-flanked PCR products (assembly order).",
            "items": {
              "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
            },
            "minItems": 1,
            "type": "array"
          },
          "restrictase": {
            "allOf": [
              {
                "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
              }
            ],
            "description": "Type IIS enzyme (catalog primary name or isoschizomer)."
          }
        },
        "required": [
          "backbone",
          "pcr_products",
          "restrictase",
          "construct_name"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "oneOf": [
                {
                  "description": "Full circular GenBank record text after assembly and annotations.",
                  "type": "string"
                },
                {
                  "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1"
                }
              ]
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Circular GenBank text of the assembled construct, or a stored-oligo handle when `options.save_results` is true.\n"
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
restriction_cloning5 operations

Restriction enzyme cloning—sites, primers, combined primers, GenBank export

POST/cloning/restriction/primersRestriction-cloning primers from user-supplied annealing sequences

operationId restriction_cloning_primers

Description

Builds full primers by adding overhangs and restriction sites to your forward/reverse annealing sequences. Validates optional overhang sizes 1–5 when set.

Products: `results.products` is a `PcrResponse`: `full_seq` (full PCR product), `restricted_seq` (insert cassette for ligation), optional Tm and cross-primer ΔG.

`melting_temperature`: Computed from `annealing_sequence` duplex physics only (cassette/overhang tails in `full_seq` do not inflate that field)—see `melting_temperature` field documentation.

Options: Omit `options` or `{}` for default overhang sizing (typically 4 bp unless overridden). `overwrite` applies when saving an oligo input. This route does not persist primer outputs.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "forward_primer": {
            "description": "Forward annealing region (DNA, 5'→3' on top strand).",
            "type": "string"
          },
          "insert": {
            "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
          },
          "options": {
            "description": "Optional; defaults apply when omitted or empty.",
            "properties": {
              "end_overhang_size": {
                "description": "Overhang length (1–5); omit for default.",
                "maximum": 5,
                "minimum": 1,
                "nullable": true,
                "type": "integer"
              },
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "start_overhang_size": {
                "description": "Overhang length (1–5); omit for default.",
                "maximum": 5,
                "minimum": 1,
                "nullable": true,
                "type": "integer"
              }
            },
            "type": "object"
          },
          "restrictases": {
            "properties": {
              "end": {
                "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
              },
              "end_seq": {
                "description": "Optional custom recognition / cut-site sequence for the end enzyme.",
                "nullable": true,
                "type": "string"
              },
              "start": {
                "example": "EcoRI",
                "nullable": true,
                "type": "string"
              },
              "start_seq": {
                "description": "Optional custom recognition / cut-site sequence for the start enzyme.",
                "nullable": true,
                "type": "string"
              }
            },
            "required": [
              "start",
              "end"
            ],
            "type": "object"
          },
          "reverse_primer": {
            "description": "Reverse annealing region (DNA).",
            "type": "string"
          }
        },
        "required": [
          "insert",
          "forward_primer",
          "reverse_primer",
          "restrictases"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "forward": {
                  "description": "One designed primer for restriction cloning: full primer (overhang + site + annealing), plus the annealing-only and site metadata used for assembly and GenBank export.\n",
                  "properties": {
                    "annealing_sequence": {
                      "description": "Region that anneals to the insert template (no overhang or RE site).",
                      "type": "string"
                    },
                    "full_seq": {
                      "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
                    },
                    "gibbs_free_energy": {
                      "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/gibbs_free_energy"
                    },
                    "hairpin_gibbs_free_energy": {
                      "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/hairpin_gibbs_free_energy"
                    },
                    "homodimer_gibbs_free_energy": {
                      "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/homodimer_gibbs_free_energy"
                    },
                    "melting_temperature": {
                      "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/melting_temperature"
                    },
                    "overhang": {
                      "description": "5' overhang sequence added for compatibility (may be empty in edge cases).",
                      "type": "string"
                    },
                    "restrictase_site": {
                      "description": "Recognition / cut-site sequence used for this end (consensus or custom).",
                      "type": "string"
                    },
                    "restriction_position": {
                      "description": "The position of a nucleotide in a DNA sequence",
                      "example": 3,
                      "format": "int32",
                      "minimum": 0,
                      "type": "number"
                    }
                  },
                  "required": [
                    "full_seq",
                    "annealing_sequence",
                    "overhang",
                    "restrictase_site",
                    "restriction_position",
                    "hairpin_gibbs_free_energy",
                    "homodimer_gibbs_free_energy",
                    "gibbs_free_energy",
                    "melting_temperature"
                  ],
                  "type": "object"
                },
                "products": {
                  "description": "In silico full-length PCR product for restriction-cloning primer design: includes overhangs, recognition sites, and insert; `restricted_seq` is the fragment intended for ligation into the vector.\n",
                  "properties": {
                    "annealing_temperature": {
                      "allOf": [
                        {
                          "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/product/properties/annealing_temperature"
                        }
                      ],
                      "nullable": true
                    },
                    "cross_primer_gibbs_free_energy": {
                      "allOf": [
                        {
                          "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/gibbs_free_energy"
                        }
                      ],
                      "description": "ΔG for forward/reverse primer dimer formation (kcal/mol), if computed.",
                      "nullable": true
                    },
                    "full_seq": {
                      "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
                    },
                    "restricted_seq": {
                      "description": "Insert-region sequence as it will be released for cloning (between cut sites).",
                      "type": "string"
                    }
                  },
                  "required": [
                    "full_seq",
                    "restricted_seq"
                  ],
                  "type": "object"
                },
                "reverse": {
                  "$ref": "#/paths/~1cloning~1restriction~1primers/post/responses/200/content/application~1json/schema/properties/results/properties/forward"
                }
              },
              "required": [
                "forward",
                "reverse",
                "products"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Forward/reverse primer details and PCR product model."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/cloning/restriction/primers_combinedRestriction-cloning primers with auto-designed annealing regions

operationId restriction_cloning_primers_combined

Description

Runs simple primer design on the insert, then adds restriction sites and overhangs like `/cloning/restriction/primers`. If `options.min_tm` is omitted or null, the inner step uses the same default as `/primers/simple` (60 °C).

Validation: If `min_tm` is set, it must be strictly between 30 and 100 °C. Overhang sizes 1–5 when provided.

Options: All optional fields may be omitted; pass `{}` for defaults. `min_length` (15–35 bp, default 18) controls the internal simple-primer step; `min_primer_length` is accepted as an alias. `overwrite` applies when saving an oligo input. This route does not persist primer outputs.

Returned `melting_temperature` semantics follow `annealing_sequence` (see primer schema), same family of estimates as `/primers/simple`.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "insert": {
            "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
          },
          "options": {
            "properties": {
              "end_overhang_size": {
                "maximum": 5,
                "minimum": 1,
                "nullable": true,
                "type": "integer"
              },
              "min_length": {
                "default": 18,
                "description": "Minimum annealing length (bp) for the internal simple-primer step (same as `/primers/simple`).\n",
                "maximum": 35,
                "minimum": 15,
                "type": "integer"
              },
              "min_tm": {
                "description": "Target Tm (°C) for the internal simple-primer step; must be in (30, 100) if set.",
                "format": "double",
                "nullable": true,
                "type": "number"
              },
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "start_overhang_size": {
                "maximum": 5,
                "minimum": 1,
                "nullable": true,
                "type": "integer"
              }
            },
            "type": "object"
          },
          "restrictases": {
            "properties": {
              "end": {
                "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
              },
              "end_seq": {
                "nullable": true,
                "type": "string"
              },
              "start": {
                "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
              },
              "start_seq": {
                "nullable": true,
                "type": "string"
              }
            },
            "required": [
              "start",
              "end"
            ],
            "type": "object"
          }
        },
        "required": [
          "insert",
          "restrictases"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "forward": {
                  "$ref": "#/paths/~1cloning~1restriction~1primers/post/responses/200/content/application~1json/schema/properties/results/properties/forward"
                },
                "products": {
                  "$ref": "#/paths/~1cloning~1restriction~1primers/post/responses/200/content/application~1json/schema/properties/results/properties/products"
                },
                "reverse": {
                  "$ref": "#/paths/~1cloning~1restriction~1primers/post/responses/200/content/application~1json/schema/properties/results/properties/forward"
                }
              },
              "required": [
                "forward",
                "reverse",
                "products"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Same shape as `/cloning/restriction/primers`."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/cloning/restriction/restrictionList compatible restriction enzymes between backbone and inserts

operationId restriction_cloning_restrictases

Description

Computes sticky Type IIP enzymes relevant to each junction: backbone–insert, insert–insert, or backbone-only when `inserts` is empty (max 10 inserts; more returns 422).

Output: An array of objects with `part1_id`, `part2_id`, and `restrictases` (name, optional position for MCS single cutters, and `recognition_site` from the backbone when a cut is reported). This is not the same shape as `/cloning/pcr/restriction` or `/cloning/gibson/restriction`, which return flat enzyme lists.

Request: `backbone`, `inserts`, and optional `options.overwrite` (default false). `backbone` and `inserts` are oligo objects (`id` loads a stored row; missing ids return 422). Repeating the same `{id, seq}` body is idempotent.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "inserts": {
            "description": "Insert fragments in order; empty array triggers backbone-only cutting.",
            "items": {
              "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
            },
            "maxItems": 10,
            "type": "array"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          }
        },
        "required": [
          "backbone",
          "inserts"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "items": {
                "description": "One logical junction in a cloning design (e.g. backbone–insert or insert–insert): which two parts are being joined and which Type IIS / IIP sticky enzymes are compatible at that junction (single-site in MCS for backbone cuts).\n",
                "properties": {
                  "part1_id": {
                    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1/properties/id"
                  },
                  "part2_id": {
                    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1/properties/id"
                  },
                  "restrictases": {
                    "items": {
                      "$ref": "#/paths/~1cloning~1pcr~1restriction/post/responses/200/content/application~1json/schema/properties/results/items"
                    },
                    "type": "array"
                  }
                },
                "required": [
                  "part1_id",
                  "part2_id",
                  "restrictases"
                ],
                "type": "object"
              },
              "type": "array"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Ordered list of junction results."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
GET/cloning/restriction/restriction/supported_restrictasesSupported sticky Type IIP enzymes for restriction cloning

operationId restriction_cloning_supported_restrictases_get

Description

Alphabetical list of enzyme names from the curated sticky-end Type IIP catalog used when scoring backbone MCS cutters and compatible junction enzymes for `/cloning/restriction/restriction` workflows. Names match the restriction enzyme catalog used elsewhere on the API; inclusion here does not imply the enzyme cuts a particular sequence.

Authentication: Bearer required (same as other cloning routes).

No request body: Empty GET request.

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "description": "Restriction enzyme identifiers, ascending lexicographic order.",
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Sorted unique enzyme names."
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/cloning/restriction/resultBuild GenBank for a restriction-cloning construct

operationId restriction_cloning_result

Description

Merges an insert (with primer binding and restriction annotations) into an existing GenBank record. Used after you have full primer sequences and restrictase positions from the primer endpoints.

Input: Provide complete GenBank as `backbone.genbank` (or a `backbone` oligo that loads GenBank). Missing GenBank returns 422. Plain-text GenBank (not a file upload)—the entire record as one string, including `ORIGIN` and `//`.

Insert: An `insert` oligo (`seq` inline or `{id}` stored).

Output: 200 `results` is the full GenBank file as a string when `save_results` is false. When `options.save_results` is true, the construct is stored (`type` construct, circular) and `results` is a handle. Failures in assembly return 500 with `message`, `error`, `success: false`. Primer JSON is not part of this response.

Primer features: `primer_bind` entries use `/label` with the restrictase name when that name is recognized in the supported enzyme catalog (e.g. EcoRI, BamHI), so cloning history is visible in the file; unrecognized names use generic `forward_primer` / `reverse_primer` labels. `/note` still describes the restriction-site remnant.

Positions: `insertion_position_1` / `insertion_position_2` control insertion vs replacement modes as described in each field (single insertion when the second position is omitted).

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "construct_name": {
            "description": "Locus / construct name for the output record.",
            "example": "pET28a_GFP_restriction",
            "type": "string"
          },
          "forward_primer_full_seq": {
            "description": "Full forward primer including overhangs and restriction site.",
            "example": "GGAATTCCATGGTGAGCAAGGGC",
            "type": "string"
          },
          "forward_primer_restrictase": {
            "description": "Enzyme name (optional). When recognized, used for remnant calculation and as the forward `primer_bind` /label in the output GenBank.\n",
            "example": "EcoRI",
            "nullable": true,
            "type": "string"
          },
          "forward_primer_restrictase_position": {
            "description": "1-based index of the cut/site within the forward primer sequence.",
            "example": 8,
            "minimum": 1,
            "type": "integer"
          },
          "insert": {
            "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
          },
          "insert_name": {
            "example": "GFP",
            "type": "string"
          },
          "insert_type": {
            "description": "Feature type label (e.g. CDS, gene)—stored in GenBank features.",
            "example": "CDS",
            "type": "string"
          },
          "insertion_position_1": {
            "description": "Primary 1-based insertion index into the sequence coordinate system.",
            "example": 100,
            "minimum": 1,
            "type": "integer"
          },
          "insertion_position_2": {
            "description": "Optional second position. When set with `insertion_position_1`, enables replacement-style logic (order determines whether the span between positions or its complement is replaced).\n",
            "example": 150,
            "minimum": 1,
            "nullable": true,
            "type": "integer"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          },
          "reverse_primer_full_seq": {
            "description": "Full reverse primer including overhangs and restriction site.",
            "example": "GGATCCCTTGTACAGCTCGTC",
            "type": "string"
          },
          "reverse_primer_restrictase": {
            "description": "Enzyme name (optional). When recognized, used for remnant calculation and as the reverse `primer_bind` /label in the output GenBank.\n",
            "example": "BamHI",
            "nullable": true,
            "type": "string"
          },
          "reverse_primer_restrictase_position": {
            "description": "1-based index of the cut/site within the reverse primer sequence.",
            "example": 7,
            "minimum": 1,
            "type": "integer"
          }
        },
        "required": [
          "backbone",
          "insert",
          "construct_name",
          "insert_name",
          "insert_type",
          "insertion_position_1",
          "forward_primer_full_seq",
          "reverse_primer_full_seq",
          "forward_primer_restrictase_position",
          "reverse_primer_restrictase_position"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "oneOf": [
                {
                  "description": "Full GenBank after insert and primer_bind annotations; /label carries enzyme names when recognized (see operation description).\n",
                  "type": "string"
                },
                {
                  "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1"
                }
              ]
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "GenBank text of the updated construct, or a stored-oligo handle when `options.save_results` is true. primer_bind features use /label with recognized restrictase names when provided (see operation description); /note describes remnants.\n"
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "500": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
restriction1 operation

Restriction enzyme search and cut-site metadata

POST/tools/restrictionMulti-enzyme digest — sites, fragments, and size-sorted lengths

operationId tools_restriction

Description

Searches the given DNA for all listed enzymes using the server’s restriction catalog and cut-site search, returns cut sites sorted by position, fragment sequences in order along the sequence, and `sizes_sorted` (fragment lengths sorted ascending).

DNA input: Provide exactly one of `seq` or `insert` (422 if more than one or none). `insert` may load a stored oligo by `id`.

Circular: When `circular` is true, scanning treats the strand as circular, including recognition motifs whose footprint spans how `seq` is written between the final and first residues. Fragment assembly wraps: the fragment from last cut through the end plus start up to first cut is the first entry in `sequences`, then intervals between successive cuts along the molecule.

Empty enzyme list: Returns no cuts; `sequences` is the full input (or empty), sizes reflect that.

Agents: Use `restrictases` for plotting cuts; use `sizes_sorted` for agarose band prediction (not the same order as `sequences`).

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "allOf": [
          {
            "description": "DNA input for sequence tools. Provide exactly one of `seq` or `insert`. Sending both, or neither, returns **422**.\n",
            "oneOf": [
              {
                "required": [
                  "seq"
                ]
              },
              {
                "required": [
                  "insert"
                ]
              }
            ],
            "properties": {
              "insert": {
                "allOf": [
                  {
                    "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
                  }
                ],
                "description": "Stored or inline DNA oligo. `id` alone loads a previously stored oligo for this key; `seq` alone is used inline and is not stored. Do not send together with `seq`.\n"
              },
              "options": {
                "description": "Optional; defaults apply when omitted or empty.",
                "properties": {
                  "overwrite": {
                    "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
                  }
                },
                "type": "object"
              },
              "seq": {
                "allOf": [
                  {
                    "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
                  }
                ],
                "description": "DNA nucleotide sequence (IUPAC). Do not send together with `insert`."
              }
            },
            "type": "object"
          },
          {
            "properties": {
              "circular": {
                "default": false,
                "description": "Treat the DNA as circular for scanning and fragment generation (including sites across the nominal junction).",
                "type": "boolean"
              },
              "restrictase_names": {
                "description": "Enzyme names from the supported catalog (e.g. EcoRI).",
                "example": [
                  "EcoRI",
                  "BamHI"
                ],
                "items": {
                  "type": "string"
                },
                "type": "array"
              }
            },
            "required": [
              "restrictase_names"
            ],
            "type": "object"
          }
        ]
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "restrictases": {
                  "description": "Cuts sorted by ascending genomic position.",
                  "items": {
                    "$ref": "#/paths/~1cloning~1pcr~1restriction/post/responses/200/content/application~1json/schema/properties/results/items"
                  },
                  "type": "array"
                },
                "sequences": {
                  "description": "Fragment sequences in locus order (see circular note above).",
                  "items": {
                    "type": "string"
                  },
                  "type": "array"
                },
                "sizes_sorted": {
                  "description": "Fragment lengths sorted smallest to largest.",
                  "items": {
                    "type": "integer"
                  },
                  "type": "array"
                }
              },
              "required": [
                "restrictases",
                "sequences",
                "sizes_sorted"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Cut map and fragment breakdown."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
tools5 operations

Sequence utilities (digest fragments, transcription, protein reverse transcription)

POST/tools/protein/reverse_transcribeReverse-transcribe protein to DNA

operationId tools_protein_reverse_transcribe

Description

Returns a DNA coding sequence that translates to the given one-letter amino acid sequence. Codon choice uses the same host table and restriction-site avoidance as codon optimization (`host`, `restrictases`).

Whitespace is stripped; letters are case-insensitive. Unsupported amino-acid symbols yield 422. Failures while assigning or recoding codons return 500 with `message`, `error`, `success: false`.

Host: Default `e.coli`; only host labels supported by the service are accepted (invalid values yield an error response).

Options: When `save_results` is true, the DNA is stored as an `insert` and `results` is a handle `{ id, type, path }` instead of `{ sequence }`. This route has no DNA oligo input; protein `sequence` is unchanged.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "host": {
            "default": "e.coli",
            "description": "Target expression host label for codon tables.",
            "example": "e.coli",
            "type": "string"
          },
          "options": {
            "description": "Optional; defaults apply when omitted.",
            "properties": {
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          },
          "restrictases": {
            "description": "Enzyme names whose sites must not appear in the output.",
            "example": [
              "EcoRI",
              "BamHI"
            ],
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "sequence": {
            "description": "Protein sequence (one-letter amino acid codes; `*` for stop).",
            "example": "MK*",
            "type": "string"
          }
        },
        "required": [
          "sequence",
          "restrictases"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "oneOf": [
                {
                  "description": "Result of protein→DNA reverse transcription. The `sequence` field is coding DNA chosen for the requested host codon usage, with listed restriction sites avoided. Length is three times the normalized protein; output is uppercase A, C, G, T with no whitespace.\n",
                  "properties": {
                    "sequence": {
                      "description": "DNA coding sequence encoding the input protein.",
                      "example": "ATGAAATAA",
                      "type": "string"
                    }
                  },
                  "required": [
                    "sequence"
                  ],
                  "type": "object"
                },
                {
                  "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1"
                }
              ]
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "DNA coding sequence in `results.sequence`, or a stored-oligo handle when `options.save_results` is true.\n"
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "500": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/tools/sequence/back_transcribeBack-transcribe RNA to DNA

operationId tools_sequence_back_transcribe

Description

Returns the DNA sequence for an RNA template: uracil (U) becomes thymine (T). Whitespace is stripped; letters are case-insensitive. Invalid symbols yield 422.

Input: Provide exactly one of `seq` or `insert`. `seq` / `insert` are DNA after T/U normalization on this route.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "$ref": "#/paths/~1tools~1restriction/post/requestBody/content/application~1json/schema/allOf/0"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "description": "Result of RNA→DNA back-transcription. The `sequence` field is DNA: uses A, C, G, and T (no U). Length matches the normalized input RNA; output is uppercase with no whitespace.\n",
              "properties": {
                "sequence": {
                  "description": "DNA sequence (thymine in place of uracil from the RNA).",
                  "example": "ATGC",
                  "type": "string"
                }
              },
              "required": [
                "sequence"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "DNA sequence in `results.sequence`."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/tools/sequence/reverse_complementReverse complement nucleotide sequence

operationId tools_sequence_reverse_complement

Description

Returns the reverse complement of the input. Works for DNA or RNA (alphabet inferred from sequence content). Whitespace is stripped; case is ignored. Invalid letters yield 422.

Input: Provide exactly one of `seq` or `insert`. This route does not persist reverse-complement output (`save_results` is not applied).

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "$ref": "#/paths/~1tools~1restriction/post/requestBody/content/application~1json/schema/allOf/0"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "description": "Result of reverse complement. The `sequence` field is nucleotide sequence on the opposite strand, 5'→3' relative to the reverse of the input: same alphabet class as the input (DNA with T and/or RNA with U, as inferred from your input), uppercase, no whitespace, same length as the normalized input.\n",
              "properties": {
                "sequence": {
                  "description": "Reverse-complement nucleotide sequence (DNA or RNA, matching input type).",
                  "example": "GCAT",
                  "type": "string"
                }
              },
              "required": [
                "sequence"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Reverse-complement sequence in `results.sequence`."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/tools/sequence/transcribeTranscribe DNA to RNA

operationId tools_sequence_transcribe

Description

Returns the RNA sequence for a DNA template: thymine (T) is represented as uracil (U) in the output. Input may contain whitespace, which is stripped; letters are treated case-insensitively. Invalid symbols for the alphabet yield 422 with a message.

DNA input: Provide exactly one of `seq` or `insert`.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "$ref": "#/paths/~1tools~1restriction/post/requestBody/content/application~1json/schema/allOf/0"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "description": "Result of DNA→RNA transcription. The `sequence` field is RNA: uses A, C, G, and U (no T). Length matches the normalized input DNA; output is uppercase with no whitespace.\n",
              "properties": {
                "sequence": {
                  "description": "RNA sequence (uracil in place of thymine from the template strand).",
                  "example": "AUGC",
                  "type": "string"
                }
              },
              "required": [
                "sequence"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "RNA sequence in `results.sequence`."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/tools/sequence/translateTranslate nucleotides to protein

operationId tools_sequence_translate

Description

Translates a DNA or RNA coding sequence to a one-letter amino acid sequence using the selected genetic code table (default 1, standard code). Optional flags match common use: stop at first stop codon (`to_stop`), or validate as a complete CDS (`cds`). Length or codon issues yield 422 with `message` (and `errors[].msg`) describing CDS / table rules—not a generic rejection only.

DNA input: Provide exactly one of `seq` or `insert`.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "allOf": [
          {
            "$ref": "#/paths/~1tools~1restriction/post/requestBody/content/application~1json/schema/allOf/0"
          },
          {
            "properties": {
              "cds": {
                "default": false,
                "description": "Strict CDS mode: validates the sequence against the genetic table (length divisible by three, leading in-frame start codon, terminating stop codon, and CDS rules).\n",
                "type": "boolean"
              },
              "to_stop": {
                "default": false,
                "description": "If true, translation ends at the first in-frame stop codon (excluded).",
                "type": "boolean"
              },
              "translation_table": {
                "default": 1,
                "description": "Genetic code table identifier (NCBI-style numeric id).",
                "minimum": 1,
                "type": "integer"
              }
            },
            "type": "object"
          }
        ]
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "description": "Result of nucleotide→protein translation. The `sequence` field is a protein: standard one-letter amino acid codes (e.g. M, K, * for stop). Stops and length depend on options (`to_stop`, `cds`) and the genetic code table used.\n",
              "properties": {
                "sequence": {
                  "description": "Translated polypeptide as a single-letter amino acid string.",
                  "example": "MK*",
                  "type": "string"
                }
              },
              "required": [
                "sequence"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Protein sequence in `results.sequence`."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
backbone2 operations

Linearize plasmid or fragment by positions or by enzyme digest

POST/backbone/linearize/restrictionLinearize backbone by restriction digest (one or two enzymes)

operationId backbone_linear_restriction

Description

Cuts a circular backbone with the server’s restriction-enzyme catalog: one enzyme (`end_restrictase` empty string) opens the circle once and returns that full-length linear molecule; two enzymes cut once each at distinct sites—typically framing the cloning region—and return rest of the linearized backbone, i.e. the remaining vector molecule after dropping the intervening fragment. Requires that the provided restrictases cut the backbone sequence once and only once (or not at all, if `end_restrictase` is empty).

Request: `start_restrictase` is required. For a single-enzyme linearization, `end_restrictase` can be omitted or sent as `""` (empty string)—the server treats that as “only `start_restrictase`”.

Backbone topology: Supply a circular plasmid sequence for typical cloning use. `backbone` is an oligo object (`id` loads a stored backbone; `seq` is inline).

Options: `overwrite` applies when saving the input. When `save_results` is true, the linearized backbone is stored (`type` backbone, linear topology) and `results` is a handle instead of `{ seq }`.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "end_restrictase": {
            "description": "Second enzyme, or empty string `\"\"` for single digest (use `\"\"` for one enzyme).\n",
            "example": "BamHI",
            "nullable": true,
            "type": "string"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          },
          "start_restrictase": {
            "description": "First (or only) enzyme name from the supported catalog.",
            "example": "EcoRI",
            "type": "string"
          }
        },
        "required": [
          "backbone",
          "start_restrictase",
          "end_restrictase"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "oneOf": [
                {
                  "properties": {
                    "seq": {
                      "description": "DNA sequence",
                      "example": "GGGTTTCCCAAAGGGTTTCCCAAATTAAGGCCTGCC",
                      "type": "string"
                    }
                  },
                  "required": [
                    "seq"
                  ],
                  "type": "object"
                },
                {
                  "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1"
                }
              ]
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Linear backbone sequence after digest—full circle opened once for single-enzyme, or the longest arm after dual digest—or a stored-oligo handle when `options.save_results` is true.\n"
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/backbone/linearize/selectionLinearize backbone by removing a segment (position-based)

operationId backbone_linear_selection

Description

Returns the linearized vector (sequence after excising the inclusive 1-based segment `[left_position, right_position]`). The excised fragment is discarded; this is the backbone you would ligate or amplify after removing an MCS region.

Adjacent cut: To open between two neighboring bases (no segment removed), use `left_position = right_position + 1` (e.g. between base 5 and base 6: `left=6`, `right=5`).

Seam cut (between last base and first): On a circle there is no base “after” the last index inside 1..L, so use `left_position = len(seq) + 1` with `right_position = len(seq)`, or equivalently `left_position = 1` and `right_position = 0`. That linearizes the full sequence without removing bases (same string; annotations stay aligned when using `backbone.genbank`).

Optional GenBank: When `backbone.genbank` is provided (full circular GenBank whose sequence matches `backbone.seq`), the response includes `results.genbank`: a linear record with features remapped to the new coordinates.

When to use enzymes instead: For cloning digests, prefer `/backbone/linearize/restriction` when you know the enzyme pair.

Backbone: Oligo object (`id` loads a stored backbone; `seq` is inline). `topology`, `mcs_start`, and `mcs_end` default as in the Backbone schema (circular plasmid, MCS often the full sequence unless narrowed).

Options: `overwrite` applies when saving the input. When `save_results` is true, the linearized backbone is stored (`type` backbone, linear topology) and `results` is a handle instead of `{ seq, genbank? }`.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "allOf": [
              {
                "$ref": "#/paths/~1oligos/post/requestBody/content/application~1json/schema/allOf/0"
              },
              {
                "description": "Plasmid or linear fragment with optional MCS bounds. Omitted `topology`, `mcs_start`, and `mcs_end` default to circular topology, MCS start 1, and MCS end equal to the length of `seq` when `seq` is present (whole sequence treated as the cloning region). When `seq` is omitted, `mcs_end` stays unset until the sequence is resolved.\n",
                "properties": {
                  "mcs_end": {
                    "description": "Multi-cloning site end (1-based), inclusive. If omitted and `seq` is present, defaults to the length of `seq` (last base of the sequence).\n",
                    "format": "int32",
                    "minimum": 0,
                    "nullable": true,
                    "type": "number"
                  },
                  "mcs_start": {
                    "default": 1,
                    "description": "Multi-cloning site start (1-based position in `seq`), inclusive. Default 1 (first base); with default `mcs_end` the full sequence is used for MCS restriction logic.\n",
                    "format": "int32",
                    "minimum": 1,
                    "type": "number"
                  },
                  "topology": {
                    "default": "circular",
                    "description": "Backbone topology; defaults to circular (typical plasmid).",
                    "enum": [
                      "linear",
                      "circular"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              }
            ]
          },
          "left_position": {
            "description": "1-based inclusive start of the segment to remove, or `len(seq)+1` for a seam cut (with `right_position = len(seq)`).\n",
            "minimum": 1,
            "type": "integer"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "default": false,
                "description": "When true, a stored oligo with the same `id` for this API key is replaced. When false (default), saving an existing id with a different `seq` or `genbank` returns **409** (`error: Conflict`, message `Oligo already exists.`). Repeating the same `id` with the same `seq` (and the same `genbank` when sent) succeeds without replacing the row. Overwriting does not consume an extra storage slot.\n",
                "type": "boolean"
              },
              "save_results": {
                "default": false,
                "description": "When false or omitted, `results` keeps this operation’s usual shape. When true, DNA or GenBank outputs are stored under this API key and `results` is an oligo handle `{ id, type, path }` (or an array of handles when this operation returns multiple sequences). New ids are server-assigned. Saving is subject to the stored-oligo cap (**403** `Oligo storage limit exceeded.` when the cap would be exceeded).\n",
                "type": "boolean"
              }
            },
            "type": "object"
          },
          "right_position": {
            "description": "1-based inclusive end of the segment to remove; use **0** only with `left_position = 1` for a seam cut (between last and first base).\n",
            "minimum": 0,
            "type": "integer"
          }
        },
        "required": [
          "backbone",
          "left_position",
          "right_position"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "oneOf": [
                {
                  "properties": {
                    "genbank": {
                      "description": "Present when a GenBank source was sent: linear GenBank with features remapped to match `seq`.\n",
                      "nullable": true,
                      "type": "string"
                    },
                    "seq": {
                      "description": "Linearized backbone (remaining sequence after excision).",
                      "type": "string"
                    }
                  },
                  "required": [
                    "seq"
                  ],
                  "type": "object"
                },
                {
                  "description": "Handle for an oligo stored under this API key. `path` includes the deployment prefix so `GET {path}` on the same host returns the full row.\n",
                  "properties": {
                    "id": {
                      "description": "The unique identifier of entity",
                      "example": "cbaa39ef-97cf-4db7-8eaf-d65d94e11bea",
                      "type": "string"
                    },
                    "path": {
                      "description": "Path of this oligo on this API, including the deployment prefix (for example `/api/oligos/{id}`).\n",
                      "example": "/api/oligos/cbaa39ef-97cf-4db7-8eaf-d65d94e11bea",
                      "type": "string"
                    },
                    "type": {
                      "description": "Stored oligo kind.",
                      "enum": [
                        "insert",
                        "backbone",
                        "construct"
                      ],
                      "type": "string"
                    }
                  },
                  "required": [
                    "id",
                    "type",
                    "path"
                  ],
                  "type": "object"
                }
              ]
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Linear backbone sequence in `results.seq` (optional GenBank in `results.genbank`), or a stored-oligo handle when `options.save_results` is true.\n"
  },
  "400": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "error": {
              "description": "Present on some 500 responses with an implementation error string.",
              "type": "string"
            },
            "errors": {
              "description": "Validation detail; list of structured error objects when present.",
              "items": {
                "additionalProperties": true,
                "type": "object"
              },
              "type": "array"
            },
            "message": {
              "description": "Human-readable summary (e.g. \"Invalid input\", \"Request body is empty\").",
              "type": "string"
            },
            "success": {
              "example": false,
              "type": "boolean"
            }
          },
          "type": "object"
        }
      }
    },
    "description": "Client or validation failure. Invalid JSON or empty body returns 400 with `message` and `success: false`. Schema or business-rule failures return 422 with `errors` (field-level list) or a single value_error entry. Authentication failures use **403** with a JSON body (shape may differ slightly from validation errors).\n"
  },
  "403": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "error": {
              "example": "Forbidden",
              "type": "string"
            },
            "message": {
              "example": "Oligo storage limit exceeded.",
              "type": "string"
            },
            "status": {
              "example": 403,
              "type": "integer"
            },
            "success": {
              "example": false,
              "type": "boolean"
            }
          },
          "type": "object"
        }
      }
    },
    "description": "Stored-oligo cap would be exceeded (`error: Forbidden`, `message` is `Oligo storage limit exceeded.`). Distinct from token-budget **403** (`error: Payment Required`).\n"
  },
  "409": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "error": {
              "example": "Conflict",
              "type": "string"
            },
            "message": {
              "example": "Oligo already exists.",
              "type": "string"
            },
            "status": {
              "example": 409,
              "type": "integer"
            },
            "success": {
              "example": false,
              "type": "boolean"
            }
          },
          "type": "object"
        }
      }
    },
    "description": "A stored oligo with this `id` already exists for the authenticated key and overwrite was not true. `error` is `Conflict`; `message` is `Oligo already exists.`\n"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
primers1 operation

PCR primer design (simple or cloning-specific)

POST/primers/simpleDesign simple PCR primers for a linear insert

operationId primers_simple

Description

Designs PCR primers for the insert sequence: returns forward/reverse primer metrics (seq, Tm, hairpin ΔG, homodimer ΔG, aggregate ΔG) and a product object with insert `seq`, recommended annealing temperature (min of the two Tm), and cross-primer ΔG.

`melting_temperature` / `annealing_temperature`: Interpret using the duplex Tm model described on those result fields—not hand-tuned NN defaults from typical notebook snippets.

RNA: Uracil is converted to thymine with a warning in logs (not an API error).

Failure: If no primers are found (e.g. extreme constraints), the server returns 500 with a generic error message.

Insert: An oligo object. A stored `{id}` loads this key’s row; `{seq}` is used inline and is not stored. `{id, seq}` / `{id, genbank}` saves. Missing stored ids return 422.

Options: Omit `options` or `{}` for defaults (`min_tm` 60 °C, `min_length` 18 bp). The legacy key `min_primer_length` is still accepted and maps to `min_length`. `overwrite` applies when saving an oligo input. This route does not persist primer outputs (`save_results` is ignored).

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "insert": {
            "allOf": [
              {
                "$ref": "#/paths/~1oligos/post/requestBody/content/application~1json/schema/allOf/0"
              }
            ],
            "description": "Insert DNA used in cloning and primer-design inputs."
          },
          "options": {
            "description": "Optional; defaults apply when omitted.",
            "properties": {
              "min_length": {
                "default": 18,
                "description": "Minimum primer length (bp) when extending toward the target Tm.\nDefault 18 bp; 15 bp is allowed for advanced users. Maximum 35 bp.\nClients may still send `min_primer_length` as an alias for this field.\n",
                "maximum": 35,
                "minimum": 15,
                "type": "integer"
              },
              "min_tm": {
                "default": 60,
                "description": "Target melting temperature (°C) for primer extension.",
                "format": "double",
                "maximum": 80,
                "minimum": 50,
                "type": "number"
              },
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              }
            },
            "type": "object"
          }
        },
        "required": [
          "insert"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "forward": {
                  "properties": {
                    "gibbs_free_energy": {
                      "description": "For primer objects, the **minimum** (more favorable / more negative) of\n`hairpin_gibbs_free_energy` and `homodimer_gibbs_free_energy` — the dominant self-structure\nconcern in this model (kcal/mol).\n",
                      "example": -3.2,
                      "format": "double",
                      "nullable": true,
                      "type": "number"
                    },
                    "hairpin_gibbs_free_energy": {
                      "description": "Predicted minimum free energy (kcal/mol) of single-strand hairpin secondary structure for this\nDNA sequence, using a standard RNA secondary-structure energy model on a T→U representation of the\nsequence.\n",
                      "format": "double",
                      "type": "number"
                    },
                    "homodimer_gibbs_free_energy": {
                      "description": "Predicted minimum free energy (kcal/mol) of homodimer cofolding (two identical strands), using the\nsame RNA secondary-structure energy model on a T→U representation of the sequence.\n",
                      "format": "double",
                      "type": "number"
                    },
                    "melting_temperature": {
                      "allOf": [
                        {
                          "example": 50,
                          "format": "double",
                          "nullable": true,
                          "type": "number"
                        }
                      ],
                      "description": "Estimated primer **Tm** (°C) using the service’s fixed **nearest-neighbour** DNA duplex model with a\n**PCR-style mixed-ion correction**—monovalent cations allowing for typical buffer alkalinity, **Mg²⁺**, free\nnucleotide triphosphates, and **equimolar primer-sized strand concentrations** in the oligomer-duplex\napproximation (not empirical 2 °C / 4 °C‑per‑base shortcuts).\n\n**Which bases are modeled (by endpoint shape):**\n\n- **`/primers/simple`** — **each primer `seq`**, i.e. the full designed oligomer strand returned.\n\n- **`/cloning/restriction/primers`** and **`/cloning/restriction/primers_combined`** — **`annealing_sequence` only**,\n  the insert-binding core **without** the 5′ overhang fragments or enzyme-site tails aggregated into `full_seq`.\n\n- **`/cloning/gibson/primers`** — **`annealing_sequence` only**. **Homology overlaps** appended for assembly\n  are **excluded from this `Tm`**. Those tails are elongated until a **separate** sliding-window duplex target\n  for `options.overlap_tm`—see overlap option text on that operation—often **lighter ion chemistry**—so overlap\n  and insert **Tm numbers are not directly comparable.**\n\n**Comparing calculators:** Offline **Tm** tooling that skips magnesium and nucleotide corrections, lowers\nassumed strand concentration, sticks to sodium-only shorthand, or uses Wallace-type heuristics often prints\n**several °C lower** for the **same substring**.\n"
                    },
                    "seq": {
                      "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
                    }
                  },
                  "required": [
                    "seq",
                    "hairpin_gibbs_free_energy",
                    "homodimer_gibbs_free_energy",
                    "gibbs_free_energy",
                    "melting_temperature"
                  ],
                  "type": "object"
                },
                "product": {
                  "description": "Full sequence of the PCR product",
                  "properties": {
                    "annealing_temperature": {
                      "allOf": [
                        {
                          "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/melting_temperature/allOf/0"
                        }
                      ],
                      "description": "Recommended PCR anneal (°C) derived from primer **Tm** fields that use the fixed nearest-neighbour +\nmixed-ion model on this API (typically the minimum of forward and reverse melting temperatures).\n"
                    },
                    "cross_primer_gibbs_free_energy": {
                      "allOf": [
                        {
                          "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward/properties/gibbs_free_energy"
                        }
                      ],
                      "description": "Gibbs free energy of forward and reverse primer dimers (kcal/mol)."
                    },
                    "seq": {
                      "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
                    }
                  },
                  "type": "object"
                },
                "reverse": {
                  "$ref": "#/paths/~1primers~1simple/post/responses/200/content/application~1json/schema/properties/results/properties/forward"
                }
              },
              "required": [
                "forward",
                "reverse",
                "product"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Designed primers and in silico product summary."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
pcr_cloning3 operations

PCR-based insert–vector constructs, blunt MCS cutters, GenBank export

POST/cloning/pcr/constructsTwo possible insert–vector concatamers (insert vs reverse complement)

operationId pcr_cloning_constructs

Description

Returns two linear sequences: linearized backbone + insert and linearized backbone + reverse_complement(insert). Does not check compatibility or open ends— callers use this as a quick combinatorial preview for PCR cloning design.

Inputs: `backbone` and `insert` oligo objects. Both DNA sequences must be non-empty (else 422).

Options: `overwrite` applies when saving oligo inputs. When `save_results` is true, both concatamers are stored as circular `construct` rows (`seq` only, no GenBank) and `results` is an array of two handles.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "insert": {
            "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          }
        },
        "required": [
          "backbone",
          "insert"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "oneOf": [
                {
                  "items": {
                    "description": "One possible full-length linear construct.",
                    "type": "string"
                  },
                  "maxItems": 2,
                  "minItems": 2,
                  "type": "array"
                },
                {
                  "items": {
                    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1"
                  },
                  "maxItems": 2,
                  "minItems": 2,
                  "type": "array"
                }
              ]
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Exactly two construct strings, or two stored-oligo handles when `options.save_results` is true.\n"
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/cloning/pcr/restrictionBlunt MCS cutters for PCR cloning (circular backbone only)

operationId pcr_cloning_restriction

Description

Returns enzymes from the supported catalog that cut once, blunt, with the site in the MCS (`mcs_start`…`mcs_end` on `backbone.seq`). Used to pick a vector linearization enzyme for PCR cloning workflows.

Linear backbones: Returns []—there is no circular MCS context.

Shape: Flat array of `{ name, position, recognition_site }` objects (not `restriction_part_pair`). Same item schema as enzyme rows in `/tools/restriction`.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          }
        },
        "required": [
          "backbone"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "items": {
                "description": "One restriction enzyme with optional 1-based cut position. Used for digest tools and MCS enzyme lists; `position` may be null in rare internal cases (enzyme name without a mapped cut).\n",
                "properties": {
                  "name": {
                    "example": "EcoRI",
                    "type": "string"
                  },
                  "position": {
                    "description": "1-based position of the cut on the forward strand when applicable.",
                    "format": "int32",
                    "minimum": 1,
                    "nullable": true,
                    "type": "integer"
                  },
                  "recognition_site": {
                    "description": "Recognition motif as it appears on the input sequence at this cut (including variable bases resolved from the target). Null when no cut position is reported.\n",
                    "example": "GAATTC",
                    "nullable": true,
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "type": "array"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Zero or more candidate enzymes with 1-based cut positions in the MCS."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/cloning/pcr/resultBuild GenBank for a PCR cloning construct

operationId pcr_cloning_result

Description

Inserts amplified insert sequence into a GenBank plasmid at defined positions, with optional primer and restriction highlights. 200 returns GenBank text in `results` (string) when `save_results` is false. When `options.save_results` is true, the construct is stored (`type` construct, circular) and `results` is a handle.

GenBank: Provide `backbone.genbank` (or a `backbone` oligo that loads GenBank). Missing GenBank returns 422.

Insert: An `insert` oligo (`seq` inline or `{id}` stored).

Optional primers: `forward_primer` / `reverse_primer` annotate binding sites when provided.

`restrictase_names`: Optional list of enzyme names to add as feature highlights.

`use_reverse_complement`: When true, the insert may be reverse-complemented and primer roles adjusted accordingly for the output record.

500 on processing errors with `message`, `error`, `success: false`.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "construct_name": {
            "example": "pET28a_GFP",
            "type": "string"
          },
          "forward_primer": {
            "example": "ATGGTGAGCAAGGGC",
            "nullable": true,
            "type": "string"
          },
          "insert": {
            "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
          },
          "insert_name": {
            "example": "GFP",
            "type": "string"
          },
          "insert_type": {
            "example": "CDS",
            "type": "string"
          },
          "insertion_position_1": {
            "example": 100,
            "minimum": 1,
            "type": "integer"
          },
          "insertion_position_2": {
            "example": 150,
            "minimum": 1,
            "nullable": true,
            "type": "integer"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          },
          "restrictase_names": {
            "example": [
              "EcoRI",
              "BamHI",
              "HindIII"
            ],
            "items": {
              "type": "string"
            },
            "nullable": true,
            "type": "array"
          },
          "reverse_primer": {
            "example": "CTTGTACAGCTCGTC",
            "nullable": true,
            "type": "string"
          },
          "use_reverse_complement": {
            "default": false,
            "type": "boolean"
          }
        },
        "required": [
          "backbone",
          "insert",
          "construct_name",
          "insert_name",
          "insert_type",
          "insertion_position_1"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "oneOf": [
                {
                  "description": "Full GenBank record text after insertion and annotations.",
                  "type": "string"
                },
                {
                  "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1"
                }
              ]
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "GenBank text of the new construct, or a stored-oligo handle when `options.save_results` is true."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "500": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
codon_optimization1 operation

Host-aware codon usage while avoiding specified restriction sites

POST/codon/optimizationCodon optimization with restriction-site avoidance

operationId codon_optimization

Description

Rewrites coding DNA for the given `host` codon usage while eliminating recognition sites for the listed `restrictases`. Returns a single optimized sequence in `results.optimized_seq`.

`restriction_sites_only`: When true, only codons overlapping restriction sites are recoded; remainder of the sequence is unchanged (e.g. targeted mutagenesis).

Insert: An `insert` oligo object. A stored `{id}` loads this key’s row; `{seq}` is inline; `{id, seq}` saves.

Options: `overwrite` applies when saving the input oligo. When `save_results` is true, the optimized DNA is stored as an `insert` and `results` is a handle `{ id, type, path }` instead of `{ optimized_seq }`.

Failures: Processing exceptions return 500 with `message`, `error`, `success: false`.

Host: Default `e.coli`; only host labels supported by the service are accepted (invalid values yield an error response).

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "host": {
            "default": "e.coli",
            "description": "Target expression host label for codon tables.",
            "example": "e.coli",
            "type": "string"
          },
          "insert": {
            "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          },
          "restrictases": {
            "description": "Enzyme names whose sites must not appear in the output.",
            "example": [
              "EcoRI",
              "BamHI"
            ],
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "restriction_sites_only": {
            "default": false,
            "description": "If true, only recode codons overlapping restriction sites.",
            "type": "boolean"
          }
        },
        "required": [
          "insert",
          "restrictases"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "oneOf": [
                {
                  "properties": {
                    "optimized_seq": {
                      "description": "DNA sequence after optimization (same protein, no listed cut sites).",
                      "example": "ATGGTGAGCAAGGGCGAGGGCGAGGGCCGACGGC",
                      "type": "string"
                    }
                  },
                  "required": [
                    "optimized_seq"
                  ],
                  "type": "object"
                },
                {
                  "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1"
                }
              ]
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Optimized coding sequence in `results.optimized_seq`, or a stored-oligo handle when `options.save_results` is true.\n"
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "500": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
mutations2 operations

Point-mutation design and application on complete coding sequences

POST/mutations/applyApply ordered mutations to a complete coding sequence

operationId mutation_apply

Description

Applies one or more substitutions to a complete coding sequence in list order and returns the mutant sequence with its translated peptide. Multi-mutant designs (for example a double mutant) are expressed as two or more entries in `mutations`.

Complete CDS required: `insert` must start with `ATG`, have a length divisible by three, and end with an in-frame stop codon. Sequences that do not satisfy this are 422.

Mutation entries: Each entry carries `coding_change` (for example `c.35G>A`) and/or `mutation_notation` (protein shorthand such as `G12D`, three-letter `p.Gly12Asp`, or a coding form). When only `mutation_notation` is given it is resolved the same way as `POST /mutations/design` and the resulting codon edit is applied. When both are given they must describe the same protein-level change, otherwise 422. An empty `mutations` list is 422.

Order matters: Each entry is validated against the sequence produced by the preceding entries, so a wild-type base or residue that an earlier entry already changed no longer matches.

Warnings: `warnings` reports substitutions that introduce a stop codon before the terminal codon (a truncated protein). Stop codons already present in the input are not reported. Warnings do not change the status code; the response is still 200.

Insert: An `insert` oligo object. A stored `{id}` loads this key’s row; `{seq}` is inline; `{id, seq}` saves. `options.overwrite` applies when saving the input oligo. When `options.save_results` is true the mutant sequence is stored as an `insert` and `results` is a handle `{ id, type, path }` instead of the inline mutant sequence, peptide, and warnings.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "insert": {
            "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
          },
          "mutations": {
            "description": "Substitutions to apply, in order. At least one entry is required.",
            "items": {
              "description": "A single substitution. Provide `coding_change`, `mutation_notation`, or both (they must then agree).\n",
              "properties": {
                "coding_change": {
                  "description": "Coding substitution in `c.<position><wildtype>><mutant>` form, 1-based.",
                  "example": "c.35G>A",
                  "type": "string"
                },
                "mutation_notation": {
                  "description": "Protein shorthand, three-letter protein form, or coding form.",
                  "example": "G12D",
                  "type": "string"
                }
              },
              "type": "object"
            },
            "minItems": 1,
            "type": "array"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              },
              "save_results": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/save_results"
              }
            },
            "type": "object"
          }
        },
        "required": [
          "insert",
          "mutations"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "oneOf": [
                {
                  "properties": {
                    "applied": {
                      "description": "Codon-level description of each substitution, in the order applied.",
                      "items": {
                        "$ref": "#/paths/~1mutations~1design/post/responses/200/content/application~1json/schema/properties/results"
                      },
                      "type": "array"
                    },
                    "protein_translation": {
                      "description": "Mutant peptide translated up to the first in-frame stop; the terminal stop residue is not included.\n",
                      "example": "MTEYKLVVVGADGVGKSA",
                      "type": "string"
                    },
                    "seq": {
                      "description": "Coding sequence after all substitutions; same length as the input.",
                      "example": "ATGACTGAATATAAACTTGTGGTAGTTGGAGCTGATGGCGTAGGCAAGAGTGCCTAA",
                      "type": "string"
                    },
                    "warnings": {
                      "description": "Non-fatal observations, such as a newly introduced internal stop codon.",
                      "example": [],
                      "items": {
                        "type": "string"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "seq",
                    "protein_translation",
                    "warnings",
                    "applied"
                  ],
                  "type": "object"
                },
                {
                  "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1"
                }
              ]
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Mutant coding sequence, translated peptide, and warnings, or a stored-oligo handle when `options.save_results` is true.\n"
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/mutations/designTranslate a mutation notation into a concrete codon edit

operationId mutation_design

Description

Resolves an HGVS-style mutation notation against a complete coding sequence and returns the codon-level edit that realizes it, without changing the input sequence. Use `POST /mutations/apply` to obtain the mutant sequence.

Complete CDS required: `insert` must start with `ATG`, have a length divisible by three, and end with an in-frame stop codon. Sequences that do not satisfy this are 422.

Accepted notations: * Protein shorthand: `G12D` or `p.G12D` * Three-letter protein form: `p.Gly12Asp` * Coding substitution: `c.35G>A`

Protein forms are validated against the translated CDS: the wild-type residue must match the residue at that position. Coding forms are validated against the sequence: the wild-type base must match the base at that position. Mismatches, positions outside the sequence, and unrecognized notations are 422.

Codon choice: For protein forms the service picks a codon for the requested residue, preferring one that differs from the wild-type codon by a single base; `coding_change` reports the first differing base as a 1-based coding position.

Insert: An `insert` oligo object. A stored `{id}` loads this key’s row; `{seq}` is inline; `{id, seq}` saves. `options.overwrite` applies when saving the input oligo.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "insert": {
            "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
          },
          "mutation_notation": {
            "description": "Mutation in protein shorthand, three-letter protein form, or coding form.",
            "example": "G12D",
            "type": "string"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              }
            },
            "type": "object"
          }
        },
        "required": [
          "insert",
          "mutation_notation"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "description": "Codon-level description of a single substitution on a complete coding sequence.",
              "properties": {
                "cds_position": {
                  "description": "1-based coding position of the substituted base reported in `coding_change`.",
                  "example": 35,
                  "minimum": 1,
                  "type": "integer"
                },
                "coding_change": {
                  "description": "Coding substitution in `c.<position><wildtype>><mutant>` form, 1-based.",
                  "example": "c.35G>A",
                  "type": "string"
                },
                "mutant_codon": {
                  "description": "Codon at that residue after the change.",
                  "example": "GAT",
                  "type": "string"
                },
                "protein_change": {
                  "description": "Protein-level result in one-letter HGVS-style form (`*` denotes a stop).",
                  "example": "p.G12D",
                  "type": "string"
                },
                "wildtype_codon": {
                  "description": "Codon at that residue before the change.",
                  "example": "GGT",
                  "type": "string"
                }
              },
              "required": [
                "protein_change",
                "coding_change",
                "wildtype_codon",
                "mutant_codon",
                "cds_position"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Codon-level description of the requested mutation."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
constructs1 operation

Post-assembly checks on a construct record (frame, stops, orientation, promoter, mutation)

POST/constructs/validateCheck an assembled construct against the intended experiment

operationId construct_validate

Description

Reads the annotations of a construct GenBank record and reports whether the cloned insert can actually be expressed as intended. Nothing is modified: a construct that fails a check is still returned as 200 with that flag false.

Insert coding sequence: the annotated `CDS` feature. When `expected.insert` is supplied, the CDS whose DNA (or translated peptide) matches it is used; otherwise the first `CDS` a promoter reads toward is used, and the first `CDS` on the record when no promoter reads toward any of them. A record with no `CDS` feature is 422. A `GCCACC` Kozak sequence annotated inside the CDS is not treated as coding; it is never required.

Checks (all booleans, all always present): * `reading_frame_preserved` — the coding sequence length is divisible by three and starts at `ATG`. * `premature_stop_codons` — true when an in-frame stop appears before the last codon. This flag reports a defect, so a healthy construct has it false. * `orientation_correct` — the CDS is on the same strand as the promoter that drives it. * `promoter_compatible` — a `promoter` feature, or any feature whose `/label` contains `CMV`, lies 5′ of the CDS along that promoter's own reading direction. * `mutation_present` — the coding sequence contains `expected.insert` DNA and its translation carries `expected.protein_change`. With neither expectation supplied this is true.

Expected mutation: `expected.protein_change` accepts protein shorthand (`G12D` or `p.G12D`) and the three-letter form (`p.Gly12Asp`); the residue at that position must be the mutant residue. Unrecognized notation is 422.

Verdict: `validation_passed` is true only when `reading_frame_preserved`, `orientation_correct`, `promoter_compatible`, and `mutation_present` are all true and `premature_stop_codons` is false.

Construct: an oligo object that must resolve to a GenBank record. `{genbank}` is inline; a stored `{id}` loads this key's construct; `{id, genbank}` saves then validates. A construct without a GenBank record, or with a record that cannot be read, is 422.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "construct": {
            "allOf": [
              {
                "$ref": "#/paths/~1oligos/post/requestBody/content/application~1json/schema/allOf/0"
              }
            ],
            "description": "Assembled cloning construct. Validation reads the annotations of its GenBank record, so `genbank` must be supplied inline or already stored under the referenced `id`.\n"
          },
          "expected": {
            "description": "What the construct should contain; omit to run the structural checks only.",
            "properties": {
              "insert": {
                "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
              },
              "protein_change": {
                "description": "Protein-level change the insert should carry, in one-letter or three-letter HGVS-style form.\n",
                "example": "p.G12D",
                "type": "string"
              }
            },
            "type": "object"
          },
          "options": {
            "description": "Optional storage flags; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              }
            },
            "type": "object"
          }
        },
        "required": [
          "construct"
        ],
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "checks": {
                  "properties": {
                    "mutation_present": {
                      "description": "Expected insert DNA and expected protein change are both found; true when no expectation was supplied.\n",
                      "type": "boolean"
                    },
                    "orientation_correct": {
                      "description": "Insert CDS on the same strand as the promoter driving it.",
                      "type": "boolean"
                    },
                    "premature_stop_codons": {
                      "description": "True when an in-frame stop codon appears before the last codon; a passing construct reports false.\n",
                      "type": "boolean"
                    },
                    "promoter_compatible": {
                      "description": "A promoter (or CMV-labelled feature) lies upstream of the insert CDS.",
                      "type": "boolean"
                    },
                    "reading_frame_preserved": {
                      "description": "Coding sequence length divisible by three and starting at ATG.",
                      "type": "boolean"
                    }
                  },
                  "required": [
                    "reading_frame_preserved",
                    "premature_stop_codons",
                    "orientation_correct",
                    "promoter_compatible",
                    "mutation_present"
                  ],
                  "type": "object"
                },
                "validation_passed": {
                  "description": "True only when every check passes and no premature stop codon was found.\n",
                  "type": "boolean"
                }
              },
              "required": [
                "validation_passed",
                "checks"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Validation verdict and the individual checks behind it."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
cloning_design1 operation

Interactive cloning strategy selection and workflow planning

POST/cloning/design/experimentDesign a cloning experiment workflow

operationId design_cloning_experiment

Description

Interactive decision tree for choosing a cloning strategy (PCR, restriction, Gibson, or Golden Gate) and evaluating backbone–insert compatibility.

Request: All fields are optional. Supply `answers` as a map of design questions (`insert_orientation`, `inserts_per_backbone`, `is_modular`). Omit or leave values null for unanswered questions—the response returns the next questions to answer.

Sequences: `inserts` and `backbone` are optional oligo objects (`id` loads a stored row; `seq` is inline). When a backbone is provided after the strategy is determined, the service evaluates MCS / cassette compatibility and returns a workflow plan with ordered API steps. Set `execute` to true to run supported analysis steps inline (restrictase listing); primer and GenBank steps remain as ready/blocked workflow entries for follow-up calls.

GenBank: Put the destination record on `backbone.genbank`.

Options: `overwrite` applies when saving oligo inputs. This route does not persist design outputs (`save_results` is not applied).

Preferred restrictases: Optional enzyme name hints for Golden Gate planning.

Response `kind`: `questions` (more input needed), `strategy` (method chosen, no backbone check yet), or `workflow` (compatibility outcome + steps).

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "answers": {
            "additionalProperties": true,
            "description": "Design answers. Keys: `insert_orientation` (`random`|`defined`),\n`inserts_per_backbone` (integer, when orientation is defined),\n`is_modular` (boolean, when more than one insert per backbone).\n",
            "type": "object"
          },
          "backbone": {
            "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/backbone"
          },
          "execute": {
            "default": false,
            "description": "When true, run supported workflow analysis steps and attach results.",
            "type": "boolean"
          },
          "execution_context": {
            "description": "Optional GenBank export context for execute mode. When provided with execute true\nand a compatible workflow, primer design and GenBank assembly steps run inline.\n",
            "properties": {
              "construct_name": {
                "type": "string"
              },
              "forward_primer_restrictase": {
                "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
              },
              "insert_name": {
                "type": "string"
              },
              "insert_type": {
                "default": "CDS",
                "type": "string"
              },
              "insertion_position_1": {
                "minimum": 1,
                "type": "integer"
              },
              "insertion_position_2": {
                "minimum": 1,
                "type": "integer"
              },
              "reverse_primer_restrictase": {
                "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
              }
            },
            "type": "object"
          },
          "inserts": {
            "items": {
              "$ref": "#/paths/~1primers~1simple/post/requestBody/content/application~1json/schema/properties/insert"
            },
            "maxItems": 10,
            "type": "array"
          },
          "options": {
            "description": "Optional; defaults apply when omitted.",
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              }
            },
            "type": "object"
          },
          "preferred_restrictases": {
            "items": {
              "$ref": "#/paths/~1cloning~1restriction~1primers/post/requestBody/content/application~1json/schema/properties/restrictases/properties/start"
            },
            "type": "array"
          }
        },
        "type": "object"
      }
    }
  }
}

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "answers": {
                  "type": "object"
                },
                "compatibility": {
                  "type": "object"
                },
                "kind": {
                  "enum": [
                    "questions",
                    "strategy",
                    "workflow"
                  ],
                  "type": "string"
                },
                "message": {
                  "type": "string"
                },
                "next_action": {
                  "type": "string"
                },
                "outcome": {
                  "enum": [
                    "compatible",
                    "need_new_backbone",
                    "need_codon_optimization_or_backbone",
                    "need_backbone_or_primer_linearization"
                  ],
                  "type": "string"
                },
                "questions": {
                  "items": {
                    "type": "object"
                  },
                  "type": "array"
                },
                "steps": {
                  "items": {
                    "type": "object"
                  },
                  "type": "array"
                },
                "strategy": {
                  "enum": [
                    "pcr_cloning",
                    "restriction_cloning",
                    "gibson_cloning",
                    "golden_gate_cloning"
                  ],
                  "type": "string"
                }
              },
              "required": [
                "kind"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Design state—questions, strategy, or workflow plan."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
api_admin1 operation

Administrative operations (API key provisioning; admin bearer required)

POST/admin/api-keysCreate a new API key (admin only)

operationId admin_api_keys_create

Description

Provisions a new bearer API key in the usage database with configurable daily and monthly token caps and a stored-oligo cap. The returned `api_key` value is the secret clients send as `Authorization: Bearer <api_key>`.

Who may call: Only admin keys (configured via environment; not the same as database-provisioned keys). Any other valid key receives 403 with an admin-only message.

Infrastructure: Requires the API key database to be configured. If it is not, the server returns 503.

Limits: Omitted body fields default to 30 000 daily and 900 000 monthly token units, and 100 stored oligos. Token values must be non-negative numbers. `oligo_limit` must be a non-negative integer.

Key value: Omit `api_key` (or send `null`) to let the server generate a random UUID. To supply your own secret (e.g. align with another system), pass a non-empty string up to 128 characters; it must not collide with an existing row (409 if duplicate).

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "properties": {
          "api_key": {
            "description": "Optional bearer secret. If omitted or null, a new UUID is generated. If set, must\nbe unique and is stored as-is (trimmed).\n",
            "maxLength": 128,
            "type": "string"
          },
          "daily_limit_tokens": {
            "default": 30000,
            "description": "Maximum token units per UTC day.",
            "format": "double",
            "minimum": 0,
            "type": "number"
          },
          "monthly_limit_tokens": {
            "default": 900000,
            "description": "Maximum token units per UTC month.",
            "format": "double",
            "minimum": 0,
            "type": "number"
          },
          "oligo_limit": {
            "default": 100,
            "description": "Maximum number of stored oligos for this key.",
            "minimum": 0,
            "type": "integer"
          }
        },
        "type": "object"
      }
    }
  },
  "required": false
}

Responses

{
  "201": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "api_key": {
              "description": "Secret bearer value for `Authorization: Bearer <api_key>`. Store securely; it is not\nshown again by the API.\n",
              "type": "string"
            },
            "created_at": {
              "description": "Creation timestamp (server time).",
              "format": "date-time",
              "type": "string"
            },
            "daily_limit_tokens": {
              "description": "Maximum token units allowed per UTC calendar day for this key.",
              "format": "double",
              "type": "number"
            },
            "id": {
              "description": "Database row id for the new key.",
              "format": "int64",
              "type": "integer"
            },
            "monthly_limit_tokens": {
              "description": "Maximum token units allowed per UTC calendar month for this key.",
              "format": "double",
              "type": "number"
            },
            "oligo_limit": {
              "description": "Maximum number of stored oligos allowed for this key.",
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "id",
            "api_key",
            "daily_limit_tokens",
            "monthly_limit_tokens",
            "oligo_limit"
          ],
          "type": "object"
        }
      }
    },
    "description": "Key created; response includes the new secret `api_key` once."
  },
  "400": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "error": {
              "example": "Bad Request",
              "type": "string"
            },
            "message": {
              "type": "string"
            },
            "status": {
              "example": 400,
              "type": "integer"
            }
          },
          "type": "object"
        }
      }
    },
    "description": "Invalid body (limits not numbers/negative, `oligo_limit` not a non-negative integer, or invalid optional `api_key`)."
  },
  "403": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "error": {
              "example": "Forbidden",
              "type": "string"
            },
            "message": {
              "example": "Admin access required.",
              "type": "string"
            },
            "status": {
              "example": 403,
              "type": "integer"
            }
          },
          "type": "object"
        }
      }
    },
    "description": "Missing admin privileges (valid bearer but not an admin key)."
  },
  "409": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "error": {
              "example": "Conflict",
              "type": "string"
            },
            "message": {
              "type": "string"
            },
            "status": {
              "example": 409,
              "type": "integer"
            }
          },
          "type": "object"
        }
      }
    },
    "description": "Duplicate `api_key` when a custom value was supplied; choose another or omit to auto-generate."
  },
  "503": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "error": {
              "example": "Service Unavailable",
              "type": "string"
            },
            "message": {
              "type": "string"
            },
            "status": {
              "example": 503,
              "type": "integer"
            }
          },
          "type": "object"
        }
      }
    },
    "description": "API key database not configured."
  }
}
quota1 operation

Usage limits and consumption for authenticated keys

GET/quota/limitsGet current usage limits and consumption

operationId quota_limits_get

Description

Returns the authenticated key’s configured caps and how many token units have been used in the current UTC calendar day and month, plus stored-oligo capacity and usage.

Quota behavior: This call does not consume token units or require spare capacity. It remains available even when daily or monthly limits are already exhausted for other endpoints.

Admin keys: Respond with `tier: admin`, `unlimited: true` (tokens), and `oligo_unlimited: true`, plus the current UTC `period` labels (no numeric caps).

Standard keys: Keys provisioned via `POST /admin/api-keys` include numeric token and stored-oligo limits, used amounts, and non-negative remainders.

Errors: 403 if the bearer is not a known key; 503 if the database is not configured for non-admin keys.

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "description": "Shape depends on `tier`. **admin** keys report unlimited token usage and unlimited stored-oligo\ncapacity. **standard** keys (stored keys) include configured token caps, stored-oligo caps, and\ncurrent usage for the UTC day and month in `period`.\n",
          "properties": {
            "api_key_id": {
              "description": "Present when `tier` is `standard`.",
              "format": "int64",
              "type": "integer"
            },
            "daily_limit_tokens": {
              "description": "Configured daily cap (standard keys).",
              "format": "double",
              "type": "number"
            },
            "daily_remaining_tokens": {
              "description": "Non-negative remainder for the current UTC day.",
              "format": "double",
              "type": "number"
            },
            "daily_used_tokens": {
              "description": "Token units consumed so far today (UTC), before this request.",
              "format": "double",
              "type": "number"
            },
            "error": {
              "description": "Present only on rare internal failures when loading metadata.",
              "type": "string"
            },
            "message": {
              "description": "Human-readable detail when `error` is present.",
              "type": "string"
            },
            "monthly_limit_tokens": {
              "description": "Configured monthly cap (standard keys).",
              "format": "double",
              "type": "number"
            },
            "monthly_remaining_tokens": {
              "description": "Non-negative remainder for the current UTC month.",
              "format": "double",
              "type": "number"
            },
            "monthly_used_tokens": {
              "description": "Token units consumed so far this month (UTC), before this request.",
              "format": "double",
              "type": "number"
            },
            "oligo_limit": {
              "description": "Maximum number of stored oligos allowed for this key (standard keys).",
              "minimum": 0,
              "type": "integer"
            },
            "oligo_remaining": {
              "description": "Non-negative remaining stored-oligo slots (`oligo_limit` minus `oligo_used`).",
              "minimum": 0,
              "type": "integer"
            },
            "oligo_unlimited": {
              "description": "Present and `true` when `tier` is `admin` (stored-oligo count is not capped).",
              "type": "boolean"
            },
            "oligo_used": {
              "description": "Current number of stored oligos for this key (standard keys).",
              "minimum": 0,
              "type": "integer"
            },
            "period": {
              "properties": {
                "utc_day": {
                  "description": "UTC date label for the daily window.",
                  "example": "2026-04-03",
                  "type": "string"
                },
                "utc_month": {
                  "description": "UTC year-month label for the monthly window.",
                  "example": "2026-04",
                  "type": "string"
                }
              },
              "required": [
                "utc_day",
                "utc_month"
              ],
              "type": "object"
            },
            "tier": {
              "enum": [
                "admin",
                "standard"
              ],
              "type": "string"
            },
            "unlimited": {
              "description": "Present and `true` when `tier` is `admin` (token usage is not capped).",
              "type": "boolean"
            }
          },
          "required": [
            "tier",
            "period"
          ],
          "type": "object"
        }
      }
    },
    "description": "Current limits and usage snapshot."
  },
  "403": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "error": {
              "type": "string"
            },
            "message": {
              "type": "string"
            },
            "status": {
              "example": 403,
              "type": "integer"
            }
          },
          "type": "object"
        }
      }
    },
    "description": "Invalid API key (or forbidden for this operation)."
  },
  "503": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "error": {
              "example": "Service Unavailable",
              "type": "string"
            },
            "message": {
              "type": "string"
            },
            "status": {
              "example": 503,
              "type": "integer"
            }
          },
          "type": "object"
        }
      }
    },
    "description": "API key database not configured (non-admin callers)."
  }
}
oligos4 operations

Per-key stored DNA fragments (inserts, backbones, and cloning constructs)—create, list, get, and delete

GET/oligosList stored oligos for this API key

operationId oligos_list

Description

Returns a page of summaries of oligos stored under the authenticated key (not full `seq` / `genbank`). Use `GET /oligos/{id}` for the complete record.

Query: `type` filters by stored kind (`insert`, `backbone`, or `construct`). Invalid `type` is 422. `limit` defaults to 50; negative values are clamped to 0 and values above 100 are clamped to 100. `offset` defaults to 0; negative values are clamped to 0. Non-integer `limit` / `offset` is 422.

Envelope: HTTP 200 with `"status": "success"` and `results: { items, total }`. `total` is the unpaged count for this key (after `type` filter). `items` may be shorter than `limit` on the last page.

Quota: This call consumes the route’s token cost. Admin keys are not subject to the stored-oligo cap.

Parameters

[
  {
    "description": "When set, only oligos of this kind are listed.",
    "in": "query",
    "name": "type",
    "required": false,
    "schema": {
      "enum": [
        "insert",
        "backbone",
        "construct"
      ],
      "type": "string"
    }
  },
  {
    "description": "Page size (default 50). Negative values are clamped to 0; values above 100 are clamped to 100.\n",
    "in": "query",
    "name": "limit",
    "required": false,
    "schema": {
      "default": 50,
      "type": "integer"
    }
  },
  {
    "description": "Number of matching rows to skip (default 0). Negative values are clamped to 0.",
    "in": "query",
    "name": "offset",
    "required": false,
    "schema": {
      "default": 0,
      "type": "integer"
    }
  }
]

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "items": {
                  "items": {
                    "description": "List view of a stored oligo. Omits `seq` and `genbank`; use `GET /oligos/{id}` for the full record.\n",
                    "properties": {
                      "created_at": {
                        "description": "When this oligo was first stored.",
                        "format": "date-time",
                        "nullable": true,
                        "type": "string"
                      },
                      "has_genbank": {
                        "description": "True when a GenBank record is stored for this oligo.",
                        "type": "boolean"
                      },
                      "id": {
                        "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1/properties/id"
                      },
                      "name": {
                        "description": "Optional caller label; not used for identity.",
                        "nullable": true,
                        "type": "string"
                      },
                      "seq_length": {
                        "description": "Length of the stored DNA in bases.",
                        "minimum": 0,
                        "type": "integer"
                      },
                      "topology": {
                        "description": "Sequence topology when known.",
                        "enum": [
                          "linear",
                          "circular"
                        ],
                        "nullable": true,
                        "type": "string"
                      },
                      "type": {
                        "description": "Stored oligo kind.",
                        "enum": [
                          "insert",
                          "backbone",
                          "construct"
                        ],
                        "type": "string"
                      },
                      "updated_at": {
                        "description": "When this oligo was last updated.",
                        "format": "date-time",
                        "nullable": true,
                        "type": "string"
                      }
                    },
                    "required": [
                      "id",
                      "type",
                      "seq_length",
                      "has_genbank"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "total": {
                  "description": "Number of matching oligos for this key (before pagination).",
                  "minimum": 0,
                  "type": "integer"
                }
              },
              "required": [
                "items",
                "total"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Paged summaries and unpaged total."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
POST/oligosCreate or overwrite a stored oligo

operationId oligos_create

Description

Persists an insert, backbone, or construct under this API key.

Required: `type` (`insert`, `backbone`, or `construct`) and either `seq` or `genbank` (or both). If `id` is omitted, the server assigns a UUID. If both `seq` and `genbank` are sent, the GenBank origin must match `seq` (422 on mismatch). GenBank-only input fills `seq` from the record origin.

Overwrite: Top-level `overwrite` (default false). Saving an existing id with a different `seq` or `genbank` without overwrite is 409. Repeating the same `id` with the same `seq` (and the same `genbank` when sent) succeeds without replacing the row. Overwrite updates in place and does not consume an extra slot.

Cap: Standard keys are limited by `oligo_limit` (default 100). A new row that would exceed the cap is 403 (`error: Forbidden`, not token Payment Required). Admin keys are unlimited but still persist.

Envelope: HTTP 201 with `"status": "success"` and `results` the full stored oligo (`seq`, `genbank`, timestamps; never `api_key_id`). This is not a handle; use compute `options.save_results` when you want `{ id, type, path }` instead of inline DNA.

There is no PATCH. Update with this endpoint and `overwrite: true`, or send `{id, seq}` on a compute route with `options.overwrite`.

Request body

{
  "content": {
    "application/json": {
      "schema": {
        "allOf": [
          {
            "description": "Stored or inline DNA fragment. All fields are optional on compute requests: `id` alone loads a previously stored oligo for this API key; `seq` alone is used inline and is not stored; `id` with `seq` and/or `genbank` saves then uses the oligo.\n",
            "properties": {
              "created_at": {
                "description": "When this oligo was first stored. Present on `/oligos` responses; omit on compute requests.",
                "format": "date-time",
                "nullable": true,
                "type": "string"
              },
              "genbank": {
                "description": "Optional GenBank record text for this oligo.",
                "type": "string"
              },
              "id": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/200/content/application~1json/schema/properties/results/oneOf/1/properties/id"
              },
              "name": {
                "description": "Optional caller label; not used for identity.",
                "type": "string"
              },
              "seq": {
                "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
              },
              "topology": {
                "description": "Sequence topology when known.",
                "enum": [
                  "linear",
                  "circular"
                ],
                "type": "string"
              },
              "type": {
                "description": "Oligo kind. Implied by the request slot when omitted on compute endpoints.",
                "enum": [
                  "insert",
                  "backbone",
                  "construct"
                ],
                "type": "string"
              },
              "updated_at": {
                "description": "When this oligo was last updated. Present on `/oligos` responses; omit on compute requests.",
                "format": "date-time",
                "nullable": true,
                "type": "string"
              }
            },
            "type": "object"
          },
          {
            "anyOf": [
              {
                "required": [
                  "seq"
                ]
              },
              {
                "required": [
                  "genbank"
                ]
              }
            ],
            "properties": {
              "overwrite": {
                "$ref": "#/paths/~1backbone~1linearize~1selection/post/requestBody/content/application~1json/schema/properties/options/properties/overwrite"
              }
            },
            "required": [
              "type"
            ],
            "type": "object"
          }
        ]
      }
    }
  },
  "required": true
}

Responses

{
  "201": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "$ref": "#/paths/~1oligos/post/requestBody/content/application~1json/schema/allOf/0"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Stored oligo (full record, including `seq` and optional `genbank`)."
  },
  "400": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/403"
  },
  "409": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/409"
  },
  "422": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
GET/oligos/{id}Get a stored oligo by id

operationId oligos_get

Description

Returns the full oligo for this API key, including `seq` and `genbank` when stored.

Missing or other-key ids: 404 (`error: Not Found`, `message` `Oligo not found.`). Compute routes that load `{id}` and do not find a row return 422 instead.

Envelope: HTTP 200 with `"status": "success"` and `results` the oligo object (no `api_key_id`).

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "$ref": "#/paths/~1oligos/post/requestBody/content/application~1json/schema/allOf/0"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Full stored oligo."
  },
  "404": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "error": {
              "example": "Not Found",
              "type": "string"
            },
            "message": {
              "example": "Oligo not found.",
              "type": "string"
            },
            "status": {
              "example": 404,
              "type": "integer"
            },
            "success": {
              "example": false,
              "type": "boolean"
            }
          },
          "type": "object"
        }
      }
    },
    "description": "No oligo with this `id` exists for the authenticated key. `error` is `Not Found`; `message` is `Oligo not found.`\n"
  }
}
DELETE/oligos/{id}Delete a stored oligo

operationId oligos_delete

Description

Hard-deletes the oligo for this API key and frees a storage slot. There is no undelete.

Missing or other-key ids: 404.

Envelope: HTTP 200 with `"status": "success"` and `results: { id }` for the deleted id.

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "id": {
                  "description": "Id that was deleted.",
                  "type": "string"
                }
              },
              "required": [
                "id"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Deleted oligo id."
  },
  "404": {
    "$ref": "#/paths/~1oligos~1%7Bid%7D/get/responses/404"
  }
}
catalog2 operations

Read-only curated cloning backbones (named plasmids such as pcDNA3.1)—list and get

GET/catalog/vectorsList curated cloning backbones

operationId catalog_vectors_list

Description

Returns the server’s read-only catalog of named backbone vectors. Each item has `name`, `description`, and `length_bp`. The catalog currently includes `pcDNA3.1`.

Envelope: HTTP 200 with `"status": "success"` and `results` an array of summaries.

Catalog entries are not stored under the API key. Persist a copy with `POST /oligos` when you need the backbone as a reusable oligo.

Quota: This call consumes the route’s token cost.

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "items": {
                "properties": {
                  "description": {
                    "description": "Human-readable summary of the backbone.",
                    "type": "string"
                  },
                  "length_bp": {
                    "description": "Length of the backbone sequence in base pairs.",
                    "minimum": 1,
                    "type": "integer"
                  },
                  "name": {
                    "description": "Catalog identifier used with `GET /catalog/vectors/{name}`.",
                    "example": "pcDNA3.1",
                    "type": "string"
                  }
                },
                "required": [
                  "name",
                  "description",
                  "length_bp"
                ],
                "type": "object"
              },
              "type": "array"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Catalog backbone summaries."
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}
GET/catalog/vectors/{name}Get a curated backbone by catalog name

operationId catalog_vector_get

Description

Returns the full backbone for a catalog `name`: `seq`, `genbank`, circular `topology`, and MCS bounds (`mcs_start`, `mcs_end`, 1-based inclusive). `type` is `backbone`.

Unknown names: 404 with `success: false`.

The record is not stored under the API key. Use `POST /oligos` to persist it.

Quota: This call consumes the route’s token cost.

Responses

{
  "200": {
    "content": {
      "application/json": {
        "schema": {
          "properties": {
            "results": {
              "properties": {
                "genbank": {
                  "description": "Full GenBank record text for this backbone.",
                  "type": "string"
                },
                "mcs_end": {
                  "description": "Multi-cloning site end (1-based, inclusive).",
                  "format": "int32",
                  "minimum": 1,
                  "type": "integer"
                },
                "mcs_start": {
                  "description": "Multi-cloning site start (1-based, inclusive).",
                  "format": "int32",
                  "minimum": 1,
                  "type": "integer"
                },
                "name": {
                  "description": "Catalog identifier.",
                  "type": "string"
                },
                "seq": {
                  "$ref": "#/paths/~1backbone~1linearize~1restriction/post/responses/200/content/application~1json/schema/properties/results/oneOf/0/properties/seq"
                },
                "topology": {
                  "description": "Sequence topology; catalog backbones are circular plasmids.",
                  "enum": [
                    "circular"
                  ],
                  "type": "string"
                },
                "type": {
                  "description": "Always `backbone` for catalog vectors.",
                  "enum": [
                    "backbone"
                  ],
                  "type": "string"
                }
              },
              "required": [
                "name",
                "type",
                "seq",
                "genbank",
                "topology",
                "mcs_start",
                "mcs_end"
              ],
              "type": "object"
            },
            "status": {
              "enum": [
                "success"
              ],
              "type": "string"
            }
          },
          "required": [
            "status",
            "results"
          ],
          "type": "object"
        }
      }
    },
    "description": "Full catalog backbone."
  },
  "403": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  },
  "404": {
    "$ref": "#/paths/~1backbone~1linearize~1selection/post/responses/400"
  }
}

Same OpenAPI document as https://api.nexio.bio/; styling matches this app.