How do I authenticate with the RoboticsCenter API?

Authentication is handled automatically by the SDK when you run rc connect or call LinkerO6.connect() / L1Robot.connect(). The SDK uses your platform.roboticscenter.ai account credentials stored in ~/.rc/config. For direct REST API calls, pass an Authorization: Bearer header using the token from the platform dashboard.

What session ID format does rc connect use?

Session IDs follow the format RC-XXXX-XXXX where each X is an alphanumeric character, e.g. RC-A7B2-X9K1. The full session URL is https://platform.roboticscenter.ai/session/RC-XXXX-XXXX. Retrieve session info with rc session RC-XXXX-XXXX.

How do I stream data from the LinkerBot O6 using Python?

Import LinkerO6 from the roboticscenter package, call LinkerO6.connect() to auto-detect the device, then iterate over device.stream(). Each frame contains normalized bend angles (0.0–1.0) for 5 fingers per hand under frame.data['left'] and frame.data['right'], plus 16 tactile pressure values.

What does SensorFrame.data contain for the VLAI L1 robot?

For the VLAI L1, frame.data contains 'joints' (a dict with 'left_arm' and 'right_arm', each a list of 7 joint angles in radians), 'base' (velocity and odometry), 'lift' (current height in mm), and 'timestamp' (Unix float with microsecond precision).

How do I create a platform session programmatically?

Use SessionManager: from roboticscenter import SessionManager; mgr = SessionManager(); session = mgr.create_session(device_type='linker_o6'). The returned session object has .session_id, .url, and .ws_url attributes. Alternatively, call the REST endpoint POST /api/teleop/sessions/create-sdk with a JSON body containing device_type.

What is the difference between LinkerO6 and L1Robot classes?

LinkerO6 drives the LinkerBot O6 dexterous hand system over USB Serial at 921600 baud using the Juqiao AA 55 03 99 framing protocol. L1Robot connects to the VLAI L1 dual-arm mobile robot over a local network via ROS2. Both expose the same stream() / stop() interface inherited from BaseDevice.

SDK Reference

RoboticsCenter SDK — Python API Reference

Complete reference for the roboticscenter Python package. Covers all public classes, methods, attributes, CLI commands, REST endpoints, and environment variables.

Package: roboticscenter Python: 3.9+ Install: pip install roboticscenter

Python SDK LinkerO6 L1Robot SessionManager REST API

Overview

The roboticscenter SDK is the primary interface for connecting robotic devices to the RoboticsCenter platform, streaming sensor data, managing teleoperation sessions, and uploading episode recordings. It ships with a CLI (rc) for quick device connection and a Python API for custom data collection pipelines.

All device classes inherit from BaseDevice and expose the same stream() / stop() interface, making it straightforward to write hardware-agnostic collection scripts.

Command-line interface

CLI Commands

The rc CLI is installed automatically with the package. Run rc --help for a full option list.

pip install roboticscenter
rc --help

Command	Description
rc devices	Scan all serial and network interfaces for connected hardware. Prints device type, port, firmware version, and status.
rc connect	Auto-detect a supported device, create a platform session, start streaming, and open the browser panel.
rc connect --device <id>	Force a specific device type. Values: `linker-o6`, `l1`. Skips auto-detection.
rc connect --port <port>	Bind to a specific serial port instead of scanning. E.g. `/dev/ttyUSB0` or `COM3`.
rc connect --mock	Start a synthetic data session with no physical hardware required. All SDK features and the browser panel are fully functional.
rc connect --no-browser	Suppress automatic browser launch. Session URL is printed to stdout.
rc session <SESSION_ID>	Show session metadata: status, device type, creation time, episode count, deep link, and upload URL.

Package

Package Import

All public classes are importable directly from the top-level package:

from roboticscenter import LinkerO6, L1Robot, SessionManager

Individual submodules are also importable for advanced use:

from roboticscenter.devices import LinkerO6, L1Robot
from roboticscenter.session import SessionManager
from roboticscenter.frames import SensorFrame

Class

LinkerO6

class LinkerO6(BaseDevice)

Driver for the LinkerBot O6 dexterous hand system. Handles USB serial framing (Juqiao AA 55 03 99 protocol at 921600 baud), packet validation, session creation, and real-time frame streaming for left and right hands simultaneously.

@classmethod
LinkerO6.connect(port=None, mock=False) → LinkerO6

Connect to an O6 hand system and return a connected device instance. Creates a platform session automatically and begins sensor streaming.

Parameter	Type	Description
port optional	str \| None	Serial port path. If `None`, scans all available ports for an O6 device. E.g. `"/dev/ttyUSB0"` or `"COM3"`.
mock optional	bool	When `True`, generates synthetic O6 sensor data. No physical device required. Default: `False`.

Returns LinkerO6 — Connected device instance. Raises ConnectionError if no O6 device is found and mock=False.

from roboticscenter import LinkerO6

device = LinkerO6.connect()
# or with explicit port:
device = LinkerO6.connect(port="/dev/ttyUSB0")
# or in mock mode:
device = LinkerO6.connect(mock=True)

device.stream() → Iterator[SensorFrame]

Yield sensor frames as they arrive from the device. Blocks until stop() is called or the device disconnects. Each frame contains a snapshot of both left and right hand state.

Parameter	Type	Description
No parameters.

Yields SensorFrame — One frame per sensor packet. frame.data shape: {"left": {"thumb": 0.0, "index": 0.0, "middle": 0.0, "ring": 0.0, "pinky": 0.0}, "right": {...}}. Values are normalized 0.0 (open) to 1.0 (fully closed).

for frame in device.stream():
    left = frame.data.get('left', {})
    right = frame.data.get('right', {})
    print(f"L index: {left.get('index', 0):.3f}  R index: {right.get('index', 0):.3f}")

device.stop() → None

Stop streaming and close the serial connection. Safe to call multiple times. Automatically flushes any buffered frames and finalizes the current recording episode if one is active.

— Attributes —

device.session_id str | None Platform session ID assigned at connect time. None if no session was created.

device.session_url str | None Full browser URL for the live teleop panel. E.g. https://platform.roboticscenter.ai/session/RC-XXXX-XXXX.

device.port str Serial port path the device is connected on. E.g. "/dev/ttyUSB0". In mock mode: "mock".

device.device_type str "linker_o6"

device.device_family str "dexhand"

Class

L1Robot

class L1Robot(BaseDevice)

Driver for the VLAI L1 mobile manipulator. Communicates via ROS2 / CAN-FD. Streams joint states, gripper positions, base velocity, lift height, battery percentage, and camera availability.

@classmethod
L1Robot.connect(port=None, mock=False) → L1Robot

Connect to an L1 robot and return a connected device instance. In hardware mode, requires a ROS2 environment and the L1 CAN-FD interface to be active.

Parameter	Type	Description
port optional	str \| None	CAN interface or ROS2 DDS endpoint override. If `None`, auto-discovers via ROS2 node graph.
mock optional	bool	Generate synthetic L1 state data. No ROS2 or physical robot required. Default: `False`.

Returns L1Robot — Connected device instance. Raises ConnectionError if the ROS2 interface is unavailable and mock=False.

robot.stream() → Iterator[SensorFrame]

Yield sensor frames from the L1 robot. Each frame contains the full robot state snapshot.

Yields SensorFrame — See frame.data structure below.

robot.stop() → None

Stop streaming and close the ROS2 / CAN-FD connection. Finalizes any active recording episode.

— SensorFrame.data structure for L1Robot —

The frame.data dictionary for an L1Robot frame has the following shape:

{
    "joints": {
        "left_arm":  [j1, j2, j3, j4, j5, j6, j7],   # degrees, 7-DOF
        "right_arm": [j1, j2, j3, j4, j5, j6, j7],   # degrees, 7-DOF
        "left_gripper":  0.0,   # 0.0 = fully open, 1.0 = fully closed
        "right_gripper": 0.0,
    },
    "base": {
        "vx": 0.0,   # forward velocity, m/s
        "vy": 0.0,   # lateral velocity, m/s
        "wz": 0.0,   # yaw rate, rad/s
    },
    "lift_height_mm": 1060,       # torso lift height in millimetres
    "battery_pct": 85.0,          # state of charge, 0.0–100.0
    "cameras": {
        "chest":       True,   # True if camera stream is active
        "wrist_left":  False,
        "wrist_right": False,
    },
}

Class

SensorFrame

class SensorFrame

A single timestamped reading from a device. Yielded by device.stream(). All attributes are read-only.

— Attributes —

frame.timestamp float Unix epoch timestamp with microsecond resolution at the moment the frame was captured on the device.

frame.device_id str Platform device identifier. For LinkerBot O6: "linker_hand".

frame.device_type str SDK device type string. For LinkerBot O6: "linker_o6". For VLAI L1: "l1".

frame.data dict Structured sensor payload. Schema varies by device type — see per-class documentation above.

frame.raw bytes Original wire-format packet bytes as received from the device. Archived verbatim in episode recordings.

Class

SessionManager

class SessionManager

Low-level client for the platform session API. Used internally by device classes, but also available for direct integration (e.g. creating sessions from a custom agent or external orchestration system).

SessionManager.__init__(base_url=RC_PLATFORM_URL)

Instantiate the session manager. RC_PLATFORM_URL defaults to https://platform.roboticscenter.ai but can be overridden via the RC_PLATFORM_URL environment variable.

Parameter	Type	Description
base_url optional	str	Platform backend URL. Override for self-hosted deployments or staging environments.

mgr.create_session(device_type, device_id=None, hardware_serial=None) → dict

Create a new teleoperation session on the platform. Returns all credentials needed to begin streaming and open the browser panel.

Parameter	Type	Description
device_type	str	SDK device type. E.g. `"linker_o6"`, `"l1"`.
device_id optional	str \| None	Human-readable device label. Defaults to the platform-assigned device ID for the type.
hardware_serial optional	str \| None	Physical device serial number. Used for per-device episode attribution in the episode browser.

Returns dict with keys:

Key	Type	Description
session_id	str	Unique session identifier. E.g. `"RC-XXXX-XXXX"`.
deep_link	str	Full browser URL for the teleop panel.
ws_url	str	WebSocket relay URL for frame streaming.
guest_token	str	Short-lived token for unauthenticated browser access to this session.
expires_at	str	ISO 8601 expiry timestamp for the session.
device_type	str	Echo of the requested device type.

from roboticscenter.session import SessionManager

mgr = SessionManager()
session = mgr.create_session("linker_o6", hardware_serial="LBO6-001")
print(session["deep_link"])
# → https://platform.roboticscenter.ai/session/RC-XXXX-XXXX

mgr.get_session_info(session_id) → dict

Retrieve current metadata for an existing session.

Parameter	Type	Description
session_id	str	The session ID returned by `create_session()` or `rc session`.

Returns dict — Session metadata including status, episode count, streaming state, and deep link. Raises NotFoundError if the session does not exist.

Direct integration

Platform REST API

The REST endpoints below are the underlying HTTP API used by the SDK. Use them for direct integration when the Python SDK is not appropriate (e.g. non-Python agents, embedded systems, or server-side orchestration).

All endpoints are relative to https://platform.roboticscenter.ai. Authentication uses the guest_token or an API key in the Authorization: Bearer <token> header.

Teleop Sessions

POST /api/teleop/sessions/create-sdk Create a new SDK session. Body: {"device_type": "linker_o6", "device_id": "...", "hardware_serial": "..."}
GET /api/teleop/sessions/{id}/sdk-info Get session metadata, streaming status, and WebSocket URL for an existing session.

L1 Pipeline

POST /api/l1/sessions/{id}/pipeline/start Start a data processing pipeline for an L1 session. Returns a pipeline_id.
GET /api/l1/sessions/{id}/pipeline/status Poll the processing pipeline status for a session.
GET /api/l1/pipeline/{pipeline_id} Get full pipeline run details by pipeline ID, including per-stage status and output artifacts.
GET /api/l1/tiers List available processing tier configurations (standard / high-fidelity / research-grade).

Configuration

Environment Variables

Variable	Default	Description
RC_PLATFORM_URL	`https://platform.roboticscenter.ai`	Backend URL used by `SessionManager` and all CLI commands. Override for self-hosted or staging deployments.

Setting in shell: export RC_PLATFORM_URL=https://staging.roboticscenter.ai
Or place in a .env file in the project root — the SDK uses python-dotenv if installed.

Hardware

Supported Devices

Device	`--device` flag	Protocol	Status
LinkerBot O6	`linker-o6`	USB Serial — Juqiao AA55 header, 921600 baud	Production
VLAI L1	`l1`	ROS2 / CAN-FD	Production

Additional devices are added in each release. Check rc devices output for dynamically discovered hardware, or consult the LinkerBot O6 hardware guide for device-specific setup instructions.

New to robotics? This is a technical API reference for SDK integrators. If you're learning the fundamentals of robotics — arms, teleop, simulation, ROS 2 — visit the SVRC Robotics Academy first. For the 5-minute install guide, see the SDK Quickstart.

Start building with the SDK

Install, connect your hardware, and stream your first episode in under five minutes.

LinkerBot O6 Guide Open Platform Contact Us