Benchling Biologics registration takes DNA or amino acid sequences as input and automatically creates and links all component entities at once, including domains, chains, variable pairs, and the protein entity itself, so you don't have to build and link each one manually. Use this article to enter your sequences, register a batch of antibodies, and review the entities Benchling creates.
During registration, Benchling annotates sequences with complementary-defining regions (CDRs), framework regions (FRs), and germline genes. It then validates each sequence for structural soundness, checking factors like CDR length, domain type, and light chain pairing. If any sequence fails validation, nothing in that batch is registered, and you'll receive an error report to fix and resubmit.
Note: Benchling Biologics requires a separate license and must be configured before registration is possible. See Configure Benchling Biologics schemas and formats to get started.
Understand the registration flow
Protein registration is an asynchronous process. After you submit, Benchling runs a pipeline that creates and links all entities, annotates sequences, and validates them against the selected germline. You’ll receive an email notification when the job is complete, either with a link to your results or a CSV of errors to fix.Registration is designed to be all-or-nothing — if Benchling detects errors during validation, nothing is created and you'll receive an error CSV.
Benchling creates the following entity types during a single registration run:
- DNA domains and/or AA domains
- DNA chains and/or AA chains
- DNA variable pairs and/or AA variable pairs
- Protein entities
Starting points: You can start from either domains or chains, and provide sequences as DNA bases, amino acid residues, or Registry IDs of existing entities. Benchling detects the input type automatically. If starting from domains, Benchling concatenates chains from those domains. When starting from domains, you can provide either variable pair entities or individual VH and VL domains. If starting from chains, Benchling decomposes chains into domains. In both cases, DNA inputs are automatically translated to AA.
Note: AA inputs are not back-translated to DNA. If you need DNA sequences for your components, prepare and register them before or after protein registration.
Registering proteins with tags or cleavage sites: If your sequences include a tag (for example, a His-tag) or a cleavage site (for example, a protease recognition sequence), Benchling can identify and label these as sub-elements during registration.
- Starting from domains: provide the sub-element sequence in its dedicated column in the template (for example, an N-terminal sub-element column).
- Starting from chains: you don't need a separate column. Benchling identifies the sub-element sequence by exclusion — any part of the chain that doesn't match a known domain — and matches it against sub-elements already registered on your tenant.
In both cases, the sub-element must already be registered on your tenant for Benchling to recognize and label it. If you're using a new tag or cleavage site that hasn't been registered yet, register it first as an AA or DNA sequence using your tenant's sub-element schema. See Create and manage entities with the Registry for details. Once a sub-element is registered, you don't need to re-register it for future antibody registrations. Sub-elements must appear as an exact match within the element. Where sub-elements overlap, Benchling labels the longest match.
Note: Labeling a sub-element as a cleavage site marks its position on the chain. It does not create a separate cleaved protein entity — Benchling does not currently support automatically generating a cleaved child entity from a cleavage site.
Pre-requisites & limitations
Before you start, review these requirements and limits so your registration runs cleanly.
- Register one format per run.
- You can register a maximum of 1,000 antibodies per run. See the FAQ for the full list of limits.
- Use domains (or variable pairs) or chains as inputs. Building-block inputs, such as constant domain groupings or an existing protein entity, aren’t supported yet.
- Each column must use a single input type across all rows: raw DNA bases, amino acid residues, or an existing registered entity name or Registry ID. Input types can vary between columns, but not within a single column.
- Existing entities you reference must already be registered. Unregistered entities aren’t supported.
- If you upload a spreadsheet, column headers must match the template exactly. Column order doesn’t matter.
- Notebook entry sections must be enabled on your tenant for the receipt feature to work.
Tip: If you already have constant domains registered in Benchling, provide the entity name or Registry ID instead of a raw sequence. This creates fewer intermediate entities and registers faster.
Fields you can set during registration: You can add protein schema fields of type text, number, boolean, and entity link, plus the protein name and alias if your naming template allows it. Dropdown, entry link, inventory link, attachment, and date fields, and required fields, aren’t supported yet. You can’t set custom fields on domains, chains, or pairs during registration. Set Target (on domains and pairs) and Species (on domains) after registration.
Register Antibodies
Configure your registration
- Click Global create, hover over Protein, and click Create proteins
- Select a format from the format picker
- Select the associated schema — Benchling auto-selects the schema if only one exists for that format
- Select a germline and numbering scheme from the Germline dropdown.
- Available germlines and schemes are shown in the dropdown.
- To use one germline for variable domains and another for constant domains, select Multiple germlines. This option appears only for formats with both variable and constant domains.
- Select your starting protein component: Domains or Chains
- If starting from domains, select whether you'll provide variable pair entities or individual VH and VL domains
- Click Next
Fill out the table
Benchling opens a table with a column for each chain or domain in your format.
- Add your sequences. Fill each chain or domain column with an existing Benchling entity or a new DNA or AA sequence, using any combination of the following:
- Type directly into a cell. To add more rows, enter a number and click Add rows.
- Paste data into the table.
- Click Add sequences and select (Entities are added below existing rows):
- Select Add from search to fill one column with existing entities. .
- Select Add from worklist to fill one column from a worklist.
- Select Add from spreadsheet to fill one or more columns from a spreadsheet. This overwrites data already in the table. See Add sequences from a spreadsheet below.
- Fill in any additional columns as needed. Depending on your protein schema, these can include Name, Alias, and protein schema fields of type text, number, boolean, or entity link.
- Click Next.
Note: To change the format or inputs you selected, click the settings icon in the top right of the table. Changing these options clears all data in the table.
Note: To save your progress, click the download icon to download the table as a spreadsheet. To pick up where you left off, restart the flow and upload the spreadsheet with Add from spreadsheet.
To add from a spreadsheet:
- Click Add sequences, then select Add from spreadsheet.
- In the modal that opens, click Download template to get the prescribed columns for your format and starting component type. Fill in the template with your sequence data.
- Upload the completed spreadsheet into the modal, then click Next.
- Confirm the Column type for each spreadsheet column. This is the chain or domain the column maps to in your format, for example, Heavy or Light for an IgG starting from chains.
- Click Upload. You return to the table, with your sequences added.
Finalize & create
- Review the entity creation summary. It shows each component type, the number of entities to create, and the schema they’ll be created in. The count doesn’t account for duplicates, so values repeated across rows are registered only once.
- Select the appropriate schemas for any component types not auto-assigned.
- If your table includes DNA inputs, select the genetic code for DNA-to-AA translation.
- Select the project folder where proteins and components will be saved
- Optionally, search for and select an existing Notebook entry to receive a summary receipt when registration completes
- Click Submit
Note: After you submit, a notification toast appears with a link to track registration progress. Don’t edit anything on that page, it’s for monitoring status only.
Review registration results
Benchling sends an email notification when registration completes, whether it succeeded or encountered errors.
If registration encounters errors:
- Open the error notification email
- Click Download errors to download a .csv (protein_creation_errors.csv) listing the issues
- Review the errors — each row identifies the issue and the affected sequence
- Fix the issues in your table or spreadsheet.
- Restart the registration flow from Global create
If registration succeeds:
- Open the success notification email
- Click View summary to open the results page, which lists every entity created, referenced, or merged during registration.
- If you sent a receipt to a Notebook entry, open the entry to find a new section with a link to the results.
- To use entities elsewhere, such as in a Notebook entry, click …, select Add to worklist, and choose the column you want.
Each entity in the results has one of three statuses:
| Status | What it means |
|---|---|
| Created | Benchling created and registered a new entity. |
| Referenced | You provided the entity by name or Registry ID, or Benchling found an existing, identical entity. |
| Merged | Benchling created a new entity, then found an identical one already existed. It merged the new entity into the existing one and archived the new entity. Variable pairs are always merged rather than referenced. |
Benchling also creates a Dataset for each run, with a column per component type and a status for each entity. The Dataset is returned as an API output and doesn’t include schema field values.
View registered proteins and sequences
Once registration is complete, open a protein entity to explore its structure and metadata.
Each protein entity includes:
- A Format field showing the VERITAS string for the format
- Chain and domain fields linking to each registered sequence
- Fieldset fields, including any computed biochemical property fields configured on your tenant
- A protein map (glyph) showing the 2D structural visualization of the molecule
Navigate the protein map: Hover over a domain in the glyph and click to open a sequence preview of that component. In the glyph, distinct chains are color-coded, variable domains appear darker than constant domains, and hinges and required linkers (in scFvs and scFabs) are represented as black lines. Optional elements appear as striped black lines and are shown only when sequences are present in those regions. Click a chain name in the legend to open the full chain sequence.
Review annotation data on sequences: During registration, Benchling annotates all new sequences and writes structured metadata to the relevant schema fields. The following data is available on domain sequence entities:
- CDR1, CDR2, CDR3 sequences
- Framework region annotations
- Closest-related V gene, J gene, and C gene, with percent identity
- Liabilities (asparagine deamidation, methionine oxidation, N-linked glycosylation, aspartate isomerization, lysine glycation, aspartic acid–proline cleavage, hydrolysis, and cysteine liabilities)
- Mutations and warnings (truncated framework regions, constant domain mutations)
Note: Benchling only annotates new sequences during registration. If you reference an existing entity by name or Registry ID, or if Benchling matches a sequence to an existing entity via uniqueness checks, that existing sequence is not re-annotated or updated.
Characterizing and validating protein entities
While registering protein entities, Benchling annotates and validates the sequences that make up proteins. Effectively, Benchling is confirming that it matches the format you specified and that it looks like a real antibody sequence. Benchling also adds annotation metadata to new sequences that you can use when designing and evaluating antibodies.
During registration, findings come back in three tiers:
Tier |
Effect on registration |
Where you see it |
|---|---|---|
Errors |
Blocks registration |
Error report, delivered by email |
Warnings |
Does not block registration |
Warnings field on the domain |
Liabilities |
Does not block registration |
Liabilities field on the domain, plus annotations on the sequence |
Note: Existing sequences used in protein registration are validated but never modified. If your import spreadsheet references an existing Benchling sequence, or we find an identical chain/domain sequence during registration while respecting uniqueness checks, we reuse it as is. We do not re-annotate it or update its metadata, so that existing data is not overwritten without your knowledge.
Characterization and validation overview
For a given a format, Benchling looks for all expected domains in each chain, in the proper order and each domain and chain is matched independently. Additionally, with the exception of element domains, all domains in a format are required.
During this process, Benchling checks for any annotation or validation errors across all entities. While there is no strict validation cutoff for domain identity, our testing shows that sequences at roughly 85% or greater identity with the reference germline annotate correctly.
During the registration process, if errors are detected it is reported and nothing is imported. In this way, registration is all or nothing. If everything succeeds: all new entities are created and registered while existing entities are reused.
There are rare exceptions where a one-off failure or a Registry validation issue can leave an import partially created. When that happens, Benchling registers some antibodies but not all, and an email notification contains a breakdown of which succeeded and which errored.
Upon registration, most metadata is written to new sequences in two places (see example in the image below):
As annotations on the domain and chain sequences (see the sequence map), so you can see it positioned on the sequence
As structured schema fields on the domain entities (see the Metadata tab), so it is searchable and reportable across your registry
How domains are annotated
Domains |
How Benchling annotates it |
What you get |
|---|---|---|
Variable - VH, VL, VHH, VA, VB |
Search against V and J genes of the germline you select, using IMGT or Kabat numbering (based on your germline choice) |
Region annotated with variable domain type, plus FR1–FR4 and CDR1–CDR3 annotations, closest V and J gene with percent identity, mutations relative to germline, and liabilities |
Constant - CL, CH1, Hinge, CH2, CH3, CH4, CA, CB |
Search against C genes of the germline you select, using EU numbering |
Region annotated with constant domain type, including closest C gene with percent identity, and mutations |
Fusion |
If provided within chains, search against preregistered fusion domains. Only exact matches are supported. If provided as domains, created automatically. |
Region annotated as “fusion,” with percent identity and mutations relative to the matched fusion domain |
Linker and element |
Found by exclusion, leaving regions not annotated by variable, constant, or fusion domains. Not aligned to a germline. Linkers are required in scFv and scFab modules. Elements are always optional and can contain any residues. |
Region annotated as “element,” with part links to any preregistered sub-elements* (tags, cleavage sites) found inside them |
*Note: Tags and cleavage sites must be preregistered in an AA and/or DNA sub-element schema in order to be found and annotated on element domains, and must appear as an exact match within the element domain. Tags and cleavage sites cannot be identified otherwise.
How CDRs and FRs are identified
Benchling’s annotation algorithm follows the following process to find CDRs and FRs:
-
First, Benchling locates FRs against germline
After the chain is decomposed into its domains, FR1–FR3 are located against the framework segments of the germline V genes and FR4 against the germline J genes. This is evaluated on amino acid sequences; any DNA input is translated using the genetic code you selected. Germline references are always translated with the Standard genetic code, so selecting a non-standard code affects only how your sequences are translated
-
Then, Benchling recovers anything the first step missed and call CDRs by exclusion
For DNA input, if an expected FR is missing from the initial germline alignment (often due to divergence from the germline through engineering or humanization), Benchling searches the interval between the neighboring FRs for the consensus amino-acid sequence of that framework in the germline you selected
Each CDR is then the span between two consecutive framework regions, so CDR boundaries follow from the framework boundaries, and therefore from the germline database you choose
-
Finally, sequences are numbered and reported
Positional numbering (IMGT or Kabat for variable domains, depending on the germline you chose) is applied and mutations are labeled in that numbering scheme
Benchling also records the closest V and J gene with percent identity
List of possible errors
Any of errors below block registration of a sequence and, as a result, any protein imported with it.
Error |
Details |
Applies to |
|---|---|---|
Expected domain could not be annotated |
Triggered when the format expects a required domain we could not place in the chain |
All domains and chains |
Domain out of order |
Triggered when a domain matches at a position that conflicts with the order declared by the format |
All domains and chains |
Two domains overlap |
Triggered when adjacent domains overlap by any number of residues |
All domains and chains |
Chain doesn’t match its domains |
Triggered when a chain’s sequence can’t be reconciled with the domains it’s declared to contain |
All chains |
Domain type doesn’t match |
Reported when a previously registered domain has a “domain type” value that doesn’t match the position in which its used in a chain |
All domains |
Light chain includes kappa and lambda |
Reported when the VL and CL domains in a light chain are not all kappa or all lambda |
VL and CL domains within a single chain |
Same CH3s in an asymmetric format |
Requires that two interacting CH3s in an asymmetric format must link to different entities |
Interacting CH3 domains in an asymmetric center |
CDR length outside the allowed range |
Evaluated within all variable domains, where CDR1 must be 3–30 AA, CDR2 3–30 AA, and CDR3 3–35 AA |
Variable domains |
Variable domain too long |
Triggered when a variable domain spans more than 250 residues (750 bases for DNA) and appears to have absorbed a neighboring domain that couldn't be placed. |
Variable domains |
No FR or CDR regions can be found at all |
Evaluated within all variable domains |
Variable domains |
CDR or FR region cannot be placed |
Evaluated within all variable domains |
Variable domains |
Ambiguous bases/residues |
Includes degenerate DNA bases or non-standard amino acids in the input |
All domains |
DNA doesn’t translate |
Triggered when a DNA sequence isn’t a multiple of 3, or doesn’t translate to its corresponding AA sequence |
All DNA domains and chains |
Frameshift mutation in a variable domain |
Reported when an insertion or deletion that isn't a multiple of 3 bases shifts the reading frame of a DNA variable domain. The message gives the approximate base position and the indel, e.g. VHH has a frameshift near base 231 (1-base deletion). Other errors on that domain, such as stop codons, are still reported. |
DNA variable domains |
Domain out of frame |
Triggered when a DNA domain's length isn't a multiple of 3, which usually means an insertion or deletion. The position of the indel isn't reported, e.g. 'CH1' out of frame. |
DNA constant and linker domains |
Internal stop codon |
Checked within each domain; a trailing terminal stop codon at the end of a chain is not flagged |
All domains and chains |
List of warnings
Warnings never block registration and are reported in the Warnings field of registered domains. The message column shows an example of the text you’ll see.
Warning |
Details |
Message |
Applies to |
|---|---|---|---|
Truncated FR region |
Reported when a FR region is shorter than its germline sequence |
|
Variable domains |
Truncated constant domains |
Reported when a constant domain is shorter than its reference sequence |
|
Constant domains |
Imperfect reference sequence match |
Reported when percent identity to the matched reference is below 100% |
|
Constant and fusion domains |
No reference sequence match |
Reported when a constant domain has no reference sequences available at all; this can occur for germlines that don’t have complete constant region coverage (e.g. the llama and alpaca germlines include no CL, and the llama germline includes no CH4) |
|
Constant domains |
Domain extension |
Reported when reference alignments leave a short span of residues uncovered between two resolved domains; when that gap sits next to a constant domain, Benchling assigns the span to that adjacent constant domain so the annotations stay contiguous and marks the added span with positioned annotations |
|
Constant domains |
Extra residues found |
Reported when residues are uncovered by the annotated domains at the start, before the next domain, or at the end. Extra residues do not need to fall inside an element domain to register, and there is no size threshold; registration fails only if the chain can’t be reconciled with its domains or a required domain is missing. |
|
Any chain |
Types of liabilities
A liability is a sequence motif associated with a known chemical or physical degradation risk. Benchling reports liabilities as sequence annotations and metadata, not as a blocker to registration. Liabilities are always reported with the region it was found in – for example, “Deamidation (CDR-H3).” Each liability is listed once per region in the Liabilities field, even if the motif occurs more than once there; every occurrence is annotated on the sequence.
Liabilities are detected on variable domains only and separately within each CDR and FR. By default, they are not detected on constant domains, hinges, linkers, element domains, or fusion domains. Any liabilities that straddle a boundary (e.g. an N-glycosylation sequon split between the end of FR3 and the start of CDR-H3) are not reported.
Each variable domain also has a Liability score. It starts at 0 and decreases by 10 for each liability or annotation warning found on that domain, so it is a simple tally, not a severity ranking or developability measure.
Motif liabilities
Liability |
Reported as |
Motif |
Applies to |
|---|---|---|---|
Asparagine deamidation |
|
|
All CDRs and FRs |
Aspartate isomerization |
|
|
All CDRs and FRs |
N-linked glycosylation |
|
|
All CDRs and FRs |
Lysine glycation |
|
|
All CDRs and FRs |
Aspartic acid – proline cleavage |
|
|
All CDRs and FRs |
Hydrolysis |
|
|
All CDRs and FRs |
Methionine oxidation |
|
|
CDRs only |
Cysteine liabilities
Benchling also flags cysteines that fall outside the expected disulfide bond pattern. Each message gives the number of cysteines found, the region, and what was expected.
Reported as |
Flagged when |
Applies to |
|---|---|---|
|
The total cysteine count is odd |
Whole variable domain |
|
More than one cysteine (one canonical framework cysteine is expected) |
FR1, FR3 |
|
Any cysteine at all |
FR2, FR4, every CDR |
Reported metadata
Field |
What it contains |
Applies to |
|---|---|---|
V gene / J gene |
Closest germline V and J gene |
Variable domains |
V gene percent identity / J gene percent identity |
Percent identity to the closest V and J gene |
Variable domains |
CDR1 / CDR2 / CDR3 |
CDR sequences |
Variable domains |
C gene |
Closest germline C gene; if several alleles match equally, the first is recorded |
Constant domains |
C gene percent identity |
Percent identity to the matched reference |
Constant domains |
Mutations |
Mutations relative to the germline or matched reference, also shown as annotations on sequences |
Variable, constant and fusion domains |
Liabilities |
Motif and cysteine liabilities (see above), also shown as annotations on sequences |
Variable domains |
Liability score |
Tally of liabilities and annotation warnings (see above) |
Variable domains |
Warnings |
Non-blocking warnings (see above) |
All domains |
FAQ
Q: Can I use registration tables to register protein entities?
A: No. Protein registration is only supported through Global create or the API. Registration tables are not supported for protein schemas. Component entities (domains, chains, and pairs) can be pre-registered through registration tables if needed.
Q: Can I start protein registration from a Notebook entry?
A: No. Registration always starts from Global create. When registration completes, you can send a receipt to an existing Notebook entry, as long as entry sections are enabled on your tenant.
Q: Can I register proteins with the API?
A: Yes. The Benchling API supports proteins, protein formats, and bulk creation and registration of proteins and their components. See the API reference for details.
Q: How long does registration take?
A: Registration time varies by format and batch size. As a general estimate, expect about 1–2 hours for 100 antibodies and 4–5 hours for 1,000, or roughly 15–20 seconds per antibody after startup. Registration may take longer in larger registries. Smaller jobs are routed to faster queues, so a single protein typically starts almost immediately.
Q: What happens if registration encounters an error?
A: Registration is all-or-nothing. If any error is detected, nothing is created, and you’ll receive an email with a CSV summarizing all errors. Fix the issues and restart the flow.
Q: Can I include sequences that are already registered in Benchling?
A: Yes. In your table or spreadsheet, provide the entity name or Registry ID instead of raw sequence data. The entity must already be registered. Benchling reuses the existing entity rather than creating a new one.
Q: Will Benchling re-annotate existing sequences if I reference them?
A: No. Benchling only annotates new sequences during registration. Existing sequences referenced by name or Registry ID, or matched through uniqueness checks, are not updated or re-annotated.
Q: Can I set custom fields during registration?
A: You can fill in protein schema fields of type text, number, boolean, and entity link, plus the protein name and alias, directly in the registration table. Dropdown, entry link, inventory link, attachment, and date fields, and required fields, aren’t supported yet. You can’t set custom fields on domains, chains, or pairs during registration. Set Target and Species on those components after registration.
Q: Can I register more than one format at a time?
A: No. Each run registers proteins of a single format. To register another format, start a new run.
Q: How many antibodies can I register in a single run?
A: Up to 1,000 antibodies per run, with the following additional limits:
- 4,000 chains per run
- 14,000 domains per run
- 45 domains per protein
- 18 domains per chain
- 1,200 amino acid residues per chain
- 3,600 DNA residues per chain
- 41,000 total entities per run
Your tenant can also run up to 20 protein registration jobs at the same time. Jobs started while 20 are already running fail and must be retried once fewer jobs are running.