Opentrons Integration

Opentrons Integration is a community skill for automating laboratory protocols on Opentrons liquid handling robots, covering protocol development, labware definition, pipette configuration, deck layout, and execution management for lab automation workflows.

What Is This?

Overview

Opentrons Integration provides tools for programming and controlling Opentrons liquid handling robots. It covers protocol development that writes Python scripts defining liquid transfer sequences and volumes, labware definition that configures plate, tube rack, and reservoir geometry for accurate positioning, pipette configuration that sets up single and multi-channel pipettes with volume calibration, deck layout that maps labware positions on the robot deck for protocol execution, and execution management that runs, monitors, and logs protocol runs on connected instruments. The skill enables scientists to automate laboratory liquid handling procedures and reduce manual intervention across routine workflows.

Who Should Use This

This skill serves laboratory scientists automating repetitive pipetting tasks, biotech teams scaling experimental protocols to higher throughput, and core facilities building reusable automation workflows. It is also well suited for research groups running plate-based assays that require consistent transfer volumes across many samples.

Why Use It?

Problems It Solves

Manual pipetting is error-prone and fatiguing for protocols requiring hundreds of individual liquid transfers across multiple plates. Reproducing complex liquid handling sequences manually leads to significant variability between experimental replicates. Scaling protocols from small to large sample counts requires systematic replanning of transfer patterns and deck layouts. Protocol documentation for manual procedures often lacks the precision of executable code, making it difficult to audit or reproduce results months later.

Core Highlights

Protocol writer creates Python scripts defining complete liquid handling procedures. Labware manager configures plate and rack geometries for the deck. Pipette controller sets up instruments with volume and tip management. Run manager executes and monitors protocols on connected robots.

How to Use It?

Basic Usage

from opentrons import (
  protocol_api)

metadata = {
  'protocolName':
    'Sample Transfer',
  'author': 'Lab Team',
  'apiLevel': '2.15'}

def run(protocol:
  protocol_api.Protocol\
    Context):
  # Load labware
  plate = protocol\
    .load_labware(
      'corning_96_well'
      '_plate_360ul_flat',
      1)
  reservoir = protocol\
    .load_labware(
      'nest_12_reservoir'
      '_15ml',
      2)
  tips = protocol\
    .load_labware(
      'opentrons_96'
      '_tiprack_300ul',
      3)

  # Load pipette
  pipette = protocol\
    .load_instrument(
      'p300_single_gen2',
      'left',
      tip_racks=[tips])

  # Transfer
  pipette.transfer(
    100,
    reservoir.wells()[0],
    plate.wells()[:12],
    new_tip='always')

Real-World Examples

def run(protocol:
  protocol_api.Protocol\
    Context):
  plate = protocol\
    .load_labware(
      'corning_96_well'
      '_plate_360ul_flat',
      1)
  reservoir = protocol\
    .load_labware(
      'nest_12_reservoir'
      '_15ml', 2)
  tips = protocol\
    .load_labware(
      'opentrons_96'
      '_tiprack_300ul', 3)

  pipette = protocol\
    .load_instrument(
      'p300_single_gen2',
      'left',
      tip_racks=[tips])

  # Add diluent
  pipette.transfer(
    100,
    reservoir['A1'],
    plate.rows()[0][
      1:12],
    new_tip='once')

  # Add sample
  pipette.transfer(
    200,
    reservoir['A2'],
    plate['A1'])

  # Serial dilution
  pipette.transfer(
    100,
    plate.rows()[0][:11],
    plate.rows()[0][1:12],
    mix_after=(
      3, 100),
    new_tip='always')

Advanced Tips

Use the protocol simulator to test scripts without a physical robot to verify transfer logic and catch errors before committing to wet lab execution. Running simulation also confirms that tip rack usage and deck positions are correctly assigned before any reagents are consumed. Define custom labware JSON files for non-standard plates and containers used in specialized experiments. Implement mix steps after dispensing to ensure uniform concentration in destination wells for accurate downstream assays.

When to Use It?

Use Cases

Automate a serial dilution protocol across a 96-well plate with consistent volumes and mixing. Transfer samples from source tubes to destination plates following a mapping spreadsheet. Build reusable protocol templates that lab members can run with different sample counts. These templates can be parameterized to accept variable inputs, reducing the need to rewrite scripts for each new experiment.

Related Topics

Opentrons, liquid handling, lab automation, protocol development, pipetting robots, laboratory workflows, and high-throughput screening.

Important Notes

Requirements

Opentrons robot hardware with compatible API version firmware installed and connected to the host computer. Opentrons Python API package for protocol development and simulation. Calibrated pipettes and verified labware positioned on the robot deck.

Usage Recommendations

Do: simulate protocols before running on the robot to verify volumes and transfer patterns match expectations. Calibrate pipettes regularly following the manufacturer guidelines to maintain accuracy. Document protocol parameters including volumes, tip types, and deck layout for reproducibility.

Don't: skip tip calibration since positioning errors cause missed wells and inaccurate transfers. Exceed pipette volume specifications since this reduces accuracy and damages instruments. Modify protocols during active runs since this can cause unexpected robot behavior.

Limitations

Protocol scripts are specific to the Opentrons API version and may need updates when firmware changes between major releases. Robot deck space limits the number of labware items available in a single protocol run. Liquid handling accuracy depends on proper calibration and liquid properties that vary significantly with viscosity, surface tension, and temperature of the solutions being transferred.