Documentation
Complete documentation for Splice cable harness design software
Harness Builder (Schematic)
Learn how to design cable harnesses with the visual builder
13 articles
Data Schema
Complete harness data structure reference
4 articles
Integrations
APIs and tools for extending Splice
2 articles
Pin Numbering Convention
Splice follows the following pin numbering conventions:
- All connectors are assigned an integer number of pins.
- By default, pin labels are assigned starting from 1 (not 0)
- Numbers increment without gaps
Custom Pin Mapping
For connectors requiring non-sequential numbering or custom labels, use the pin_mapping field. This field maps pin indices (as strings) to custom labels.
Example with numeric labels:
pin_mapping: {
"0": "1", // Pin 0 maps to the label 1 (Default)
"1": "3", // Pin 1 maps to the label 3
"2": "4", // Pin 2 maps to the label 4
}Example with functional labels:
pin_mapping: {
"0": "GND", // Pin 0 maps to the label GND
"1": "24V", // Pin 1 maps to the label 24V
"2": "TX", // Pin 2 maps to the label TX
"3": "RX" // Pin 3 maps to the label RX
}Bridged Positions
To denote electrically bridged pins, define a bridged_positions array using mapped pin labels:
pin_mapping: {
"0": "GND_1", // Pin 0 maps to the label GND_1
"1": "GND_2", // Pin 1 maps to the label GND_2
}bridged_positions: [["GND_1", "GND_2"]]This example shows pins labeled GND_1 and GND_2 are internally connected.
Contact Gender Definition
Connector gender in Splice refers explicitly to the type of electrical contacts:
- Male (Pin): Protruding pins that insert into female contacts
- Female (Socket): Receptacle contacts that accept male pins
- None: Used for non-standard or genderless connectors
Visual Representation & Connector Insets
In the Splice interface, connector gender affects the visual representation with distinct insets for each view:
Male pins are denoted by dark circles with white text:
Female receptacles are denoted by outlined white circles with dark text:
Making & Modifying Connections
This guide explains what happens when you click on pins or cable cores to create, extend, or change connections in Splice.
Connection Scenarios
Creating a New Connection
-
Click an unconnected pin on a connector block.
The Pending Wire banner appears at the bottom of the screen.
-
Click a second target:
- Connector pin - a wire is created using the pending specs (AWG, color, etc.).
- "TIN" / "BARE" / "HS" flying-lead port - a flying lead is created with the same specs.
- Cable core - a cable core segment is created using the cable core's own specs (AWG, color, strand count, etc.), and linked to the pending wire.
Adding an Additional Connection
- Click a pin with one or more existing connections.
An action menu appears.
- Select "Add Connection."
You enter Pending Wire mode again.
- Complete the connection: Click the target pin or core to finish the new wire or lead.
Moving or Swapping an Existing Connection
- Click a pin with connections.
The action menu opens.
- Choose the wire you want to move or swap in the "Move/Swap/Twist Existing Connections" block.
Move vs. Swap Examples
Bulk Connect (Connection Matrix)
When you need to wire two connectors together quickly, use the Connection Matrix. Select exactly two connectors in the Bulk Property Editor Components tab and click Bulk Connect.
The matrix shows a 2D grid — rows are pins of connector 1, columns are pins of connector 2. Click cells to create connections, or use one of the built-in patterns:
- 1:1 — straight mapping (pin 1→1, pin 2→2, etc.)
- Reversed — mirror mapping (pin 1→last, pin 2→second-last, etc.)
- Interleave — swap adjacent pairs (1→2, 2→1, 3→4, 4→3) for twisted pair wiring
- Clear — remove all pending connections
Set default color, stripe, and AWG in the toolbar before applying a pattern, or click individual pending connections to customize each wire's properties. When one component is a cable, core properties are used automatically.
Command-Based Undo/Redo
Every action in the Harness Builder can be undone or redone.
- Component addition & deletion
- Component positioning
- Wire swapping & movement
- Auto-routing & manual routing (wires & cores)
- Signal renaming
- Design-note editing
Usage
- Keyboard: Ctrl + Z / Cmd + Z to undo, Ctrl + Y / Cmd + Shift + Z to redo.
- Toolbar: Click the Undo/Redo icons - hover to preview recent actions.
Box Select & Group Repositioning
Select multiple items — components, wire anchors, or cables — and move, auto-route, or delete them in a single action. Splice supports two selection modes depending on which direction you drag.
Window Selection (Drag Right)
Click on an empty area and drag to the right to create a blue solid rectangle. Only items fully enclosed by the rectangle are selected.
Crossing Selection (Drag Left)
Click on an empty area and drag to the left to create a green dashed rectangle. Any item that intersects the rectangle is selected — items don't need to be fully enclosed.
Modifier Keys
- Shift or Ctrl/Cmd — Add to the current selection (items already selected stay selected)
- Alt/Option — Remove items from the current selection
- No modifier — Replace the current selection entirely
You can also Ctrl+Click (or Cmd+Click) individual items to toggle them in and out of the selection.
Group Dragging
When items are selected, their drag handles turn blue. Drag any selected item to reposition the entire group while preserving relative positions.
Selection Actions
After selection, a toolbar appears at the bottom of the screen with quick actions:
- Auto-route selected wires and cable cores
- Delete selected components
- Copy / Paste connectors and cables
Generic Components
Add components that don't exist in the library directly from the Harness Builder. Use category templates for quick schematic-style symbols, or upload your own image for a custom look.
Creating a Generic Component
- Open the Components floating panel by clicking the connector icon on the right side of the canvas, or press C
- Click the Create button in the panel header
- Select a category template from the dropdown (power supply, circuit breaker, relay, contactor, fuse, switch, push button, fan, motor, timer, PCB, etc.) to use a built-in schematic symbol, or start from scratch
- Set the number of positions for your component
- Optionally enter an MPN and click the magic wand button to auto-fill details from Digi-Key (manufacturer, description, datasheet, image)
- Keep the category template icon, or upload/paste your own custom image (SVG or PNG)
Editing a Generic Component
To modify a generic component after adding it to the canvas:
- Right-click the component and select Edit Properties
- Or click the tune icon in the component's toolbar when selected
You can update the category, number of positions, part details, and custom graphics at any time.
Component Categories
Available categories include:
Circuit Breakers: Overcurrent protection
Fuses: One-time overcurrent protection- radio_button_checkedPush Buttons: Momentary and latching controls
- toggle_onSwitches: Manual control elements
Relays: Electromechanical switching- electrical_servicesContactors: Heavy-duty power switching
- powerPower Supplies: Voltage conversion modules
Motors: Electric motor components- airFans: Cooling and ventilation
- memoryPCBs: Printed circuit boards
Resistors: Fixed and variable resistors
Capacitors: Energy storage components
Diodes: Rectifiers and semiconductor switches
Inductors: Coils and chokes
Transformers: Voltage transformers
Inverters: DC-to-AC conversion- call_splitSplices: Wire joining and connections
- battery_charging_fullBatteries: Power cells and packs
Solar Cells: Photovoltaic modules- categoryOther: Miscellaneous components
Shape-Based Categories
You can also browse connectors by shape:
Circular: Round multi-pin connectors- usbUSB: Universal Serial Bus connectors
D-Sub: D-subminiature connectors
Rectangular: Rectangular connectors
Ferrule: Wire-end sleeve terminals
Quick Disconnect: Spade and blade terminals
Ring Terminal: Ring and lug terminals
Terminal Block: Barrier strip connectors
Generic Cables
Add cables that don't exist in the library directly from the Harness Builder. This streamlines your workflow when you need cables with custom specifications.
Creating a Generic Cable
- Open the Cables floating panel by clicking the cable icon on the right side of the canvas, or press B
- Click the Create button in the panel header
- Specify the number of cores for your cable
- Set the wire gauge (AWG) for the cores
- Toggle shielding options if needed
- Set core colors individually or apply standard color codes
- Optionally add part details (manufacturer, MPN)
Editing a Generic Cable
To modify a generic cable after adding it to the canvas:
- Right-click the cable and select Edit Properties
- Or click the tune icon in the cable's toolbar when selected
You can update the number of cores, wire gauge, shielding, core colors, and part details at any time.
Cable Properties
- Number of Cores: How many individual conductors the cable contains
- Wire Gauge: AWG size for the cable cores
- Shielding: Optional overall shield for EMI protection
- Core Colors: Individual wire colors for identification
- Part Details: Manufacturer, MPN, description for BOM generation
Custom Graphics
Add custom visuals to any component using the image upload feature. This is ideal for adding datasheet images, manufacturer graphics, or custom drawings to your components.
Upload Methods
- File Upload: Click "Upload SVG or PNG" to select files from your computer
- Clipboard Paste: Use Win+Shift+S (Windows) or Cmd+Shift+4 (Mac) to capture a screen region, then click the paste button
Supported Formats
- SVG: Vector graphics that scale without losing quality
- PNG: Raster images with transparency support
Mate and Wire Side Images
Components in Splice have two sides:
- Mate Side: The side that connects to another component (typically shows the connector face)
- Wire Side: The side where wires attach (typically shows terminals or solder cups)
You can upload different images for each side of the component to accurately represent both views.
Bundle Labels
Add visual labels to connectors on your harness canvas to identify sections, add assembly instructions, or mark test points.
Adding Labels
- Click a connector on the canvas to show its toolbar
- Click the label icon in the toolbar
- Click Add Label to create a new label
- Enter the label text and customize the appearance
- Associate the label with specific wires if needed
Label Properties
- Label Text: The text displayed on the label
- Background Color: The fill color of the label tag
- Text Color: The color of the label text
- Wire Association: Which wires the label applies to
Multiple Labels
You can add as many labels as needed to each connector. Each label can be associated with different wires, making it useful when a single connector has multiple label requirements.
Visibility Control
Toggle label visibility in the label editor dialog. This allows you to show or hide all labels on the canvas without deleting them.
Wire Label Export
Labels can be exported for use with heat-shrink label printers:
- Click a connector and then click the label icon
- Configure label settings and wire associations
- Download label data compatible with popular heat-shrink printer software
Use Cases
- Identifying harness sections or branches
- Adding assembly instructions
- Marking test points or inspection locations
- Color-coding by function or destination
- Generating wire labels for heat-shrink printing
PDF Export Options
Configure how your harness design is exported to PDF, including BOM placement, Connection Tables, and Cut Lists.
Simple Engineering Drawing
Export a single-page PDF engineering drawing via Download & Upload > Engineering Drawing:
- Full-page harness diagram with title block
- Bill of Materials on a separate page
- Connection Table showing all wire connections grouped by bundle
- Cut List with consolidated wire requirements
Multi-Page PDF Export
Create professional multi-page engineering documentation:
- Click the PDF Pages button on the right toolbar
- Add pages with custom sizes (A2, A3, A4, Letter, or custom)
- Position and scale page frames over different areas of your design
- Toggle the "BOM on separate page" option to control BOM placement
- Export via Download & Upload > Multi-Page PDF
BOM Placement
The "BOM on separate page" toggle in the PDF Pages panel controls how the Bill of Materials is rendered:
- Enabled (default): BOM renders on dedicated page(s) after the diagram pages. The diagram uses the full page area.
- Disabled: BOM overlays on each diagram page in a corner position. Useful for single-page exports where you want everything visible at once.
When BOM is on separate pages, the PDF structure is:
- Diagram page(s)
- Bill of Materials page(s)
- Connection Table page(s)
- Cut List page(s)
Connection Table
The Connection Table provides a detailed wire-by-wire breakdown of all connections:
- Grouped by bundle: Connections organized by wire bundles (e.g., "Bundle X1 | X2") and cables (e.g., "Cable C1")
- Full connection details: From/To pins, signal labels, wire color, AWG, and length
- Bundle labels: Shows bundle labels at each connection end
- Cable cores: Lists all cable cores including shield connections
- Flying leads: Displays termination type for unterminated wires
Connection Tables are included automatically in multi-page PDF exports and can be downloaded separately via Download & Upload > Connection Table.
Cut List
The Cut List consolidates wire and cable requirements for manufacturing:
- Wire consolidation: Groups wires by MPN and manufacturer with total length calculations
- Individual lengths: Shows length distribution (e.g., "3 x 200mm, 2 x 350mm") for cutting planning
- Cable support: Includes multi-core cables with total length
- Bundle labels: Shows which wire bundles use each wire type
Export formats:
- CSV: For spreadsheet applications
- Excel (XLSX): Formatted spreadsheet with headers
- PDF: Professional document with summary totals
Access via Download & Upload > Cut List.
Wire Anchors
Wire anchors are control points on the schematic canvas that set the vertical jog location of wire paths and cable cores between connectors. By default, wire anchors are auto-routed — Splice positions them automatically when connections are created. Hover over any wire or cable core to reveal its anchor and enable repositioning by dragging.
Box Select & Group Drag
Wire anchors are fully supported by box select — use window selection (drag right) or crossing selection (drag left) to select multiple wire anchors at once. When you drag any selected item, the entire group moves while preserving the spacing between elements.
You can also include connectors, wire bundle blocks, and cable blocks in the same selection — keeping your entire layout intact when repositioning.
Distribute
When multiple wire anchors are selected, use the distribute function to evenly space them apart and flip the jog ordering for better visibility. This is useful for cleaning up overlapping bundles and creating a tidy, readable schematic.
Bulk Property Editor
The Bulk Property Editor is a comprehensive panel for editing harness properties in bulk — connectors, wires, cables, and accessories — without clicking through individual components on the canvas. Open it by pressing E or clicking the Bulk Editor button in the right sidebar. The panel can float on the canvas or be pinned to the dock.
Components Tab
Edit connector properties and manage terminal assignments. The tab has two sub-views:
Pins View
Lists all connectors with expandable pin tables showing pin index, label, connected wire/core, and the destination. Pin labels are editable inline, and individual connections can be deleted directly.
Contacts View
Assign terminal contacts to connector pins. Pins are automatically grouped by the AWG of the wire connected to them:
- Click the search icon to open a picker with compatible contacts for that connector and AWG
- Use "Apply to all [AWG] AWG" to assign the same terminal to every pin in that gauge group
- Clear all terminals for an AWG group with one click
Other component actions include inline editing of designator, manufacturer, and MPN, auto-renumbering connectors (left-to-right or top-to-bottom), and the Bulk Connect dialog when two connectors are selected.
Wires Tab
Edit wire properties in bulk, organized by bundle. Each bundle header provides controls for setting length, color, stripe, and AWG for all wires in the bundle at once. The tab has two sub-views:
Signals View
Manage signal labels for each wire. Columns show color, stripe, AWG, and two editable signal labels per wire. This view also supports twisted pair grouping — select wires and create twist groups, add wires to existing groups, or dissolve pairs.
Properties View
Assign wire part numbers (MPNs) and view electrical properties:
- Click the search icon on any wire to find matching parts by AWG, color, and stripe
- Select a wire part to assign its MPN, manufacturer, voltage rating, and certifications
- Copy/paste wire properties between rows — or use "Paste to Similar" to apply to all wires with matching AWG, color, and stripe
- Assignments are non-destructive overrides — original part data is preserved and can be restored with Reset
Cables Tab
Edit cable properties and stripping schedules. Each cable shows its designator, manufacturer, MPN, length, core count, and shielding status. Expand a cable to see:
- Core list with color swatches, connection endpoints, and editable signal labels (including shield core)
- Strip lengths per connector end — editable fields for jacket, shield, insulation, and core strip lengths
- Copy/paste stripping values between entries or paste to all entries for a cable
Accessories Tab
Manage protective and functional accessories attached to cables and bundles — heat shrink (HS), conduit (CV), braid (BR), cable ties, sheath, spiral wrap, labels, and more. Each accessory has:
- Type badge (click to change), position along the bundle with end reference, length
- Part number, manufacturer, and description
- Add, delete, and copy/paste accessory properties between entries
Save / Cancel Workflow
All changes across every tab are staged as pending changes, highlighted in blue until you save. Click Save to commit all changes at once (with full undo/redo support), or Cancel to discard everything.
Data Schema Overview
The Splice harness schema defines the complete structure of cable harness data for storage, export, and interchange.
For full schema documentation, visit the AI Integration Schema which provides the complete JSON structure.
Core Data Structures
- BOM (Bill of Materials): Contains all parts used in your harness including connectors, wires, cables, and terminals
- Mapping: Defines wire connections between termination points
- Positions: Stores visual layout coordinates for components
- Design Notes: Text annotations attached to the harness
Export Formats
Harness data can be exported in multiple formats:
- JSON: Full schema for programmatic access
- CSV: BOM export for spreadsheet applications
- WireViz: YAML format for WireViz diagram generation
- PDF: Printable documentation with diagrams
Key Generation Convention
Splice uses a structured, hierarchical key system to ensure consistent and unique identifiers across all data structures.
BOM Instance Keys
All parts in the BOM use sequential letter-number combinations:
- Connectors: use prefix
Xand increment: X1, X2, X3, ... - Wires: use prefix
Wand increment: W1, W2, W3, ... - Cables: use prefix
Cand increment: C1, C2, C3, ... - Terminals: use prefix
Tand increment: T1, T2, T3, ... - Splices: use prefix
SPand increment: SP1, SP2, SP3, ...
Mapping Keys (Connections)
Connection keys in the mapping object follow specific patterns:
- Wire Connections: Use BOM wire key directly (W1, W2, etc.)
- Cable Core Connections: Use format
CableInstance.CoreNumber(e.g., C1.1, C1.2) - Bundle Keys: Connector pairs sorted alphabetically as
Connector1|Connector2(e.g., X1|X2)
Position Keys
Position keys directly correspond to BOM instance keys:
- Connector Positions:
connector_positions["X1"]stores position for connector X1 - Cable Positions:
cable_positions["C1"]stores position for cable C1
Wire Anchor Keys
Wire anchor keys store label positioning data and are generated based on connection types.
- Connector-to-Connector Bundles: X1|X2 (sorted alphabetically)
- Flying Lead Connections: Individual wire key W1, W2, etc.
- Cable Core Connections: Cable core key with suffix
-1or-2to denote cable side, eg. C1.1-1, C1.2-2, etc.
Bundle Labels
Bundle labels store visual labels attached to connectors or cables:
- Key: Unique UUID for each label
- connector_instance_id: The connector this label is attached to (e.g., "X1")
- cable_instance_id: The cable this label is attached to (e.g., "C1")
- label_text: The text displayed on the label
- wire_keys: Optional array of specific wire keys this label applies to
- width_mm: Label width in millimeters (default: 9)
- text_color: Hex color for label text (default: "#000000")
- background_color: Hex color for label background (default: "#FFFFFF")
Label Settings
Global settings for label display:
- show_labels_on_canvas: Boolean to toggle label visibility
- default_width_mm: Default width for new labels in millimeters
Key Hierarchy Example
{
"bom": {
"X1": "Connector instance",
"W1": "Wire instance",
"C1": "Cable instance"
},
"data": {
"mapping": {
"W1": "Wire connection",
"C1.1": "Cable core 1 connection",
"C1.2": "Cable core 2 connection"
},
"connector_positions": {
"X1": "Connector X1 position"
},
"cable_positions": {
"C1": "Cable C1 position"
},
"wire_anchors": {
"X1|X2": "Bundle label anchor",
"W1": "Flying lead label anchor",
"C1.1-1": "Cable core label anchor"
},
"bundle_labels": {
"uuid-1234": {
"connector_instance_id": "X1",
"label_text": "TO POWER SUPPLY",
"wire_keys": ["W1", "W2"],
"width_mm": 9,
"text_color": "#000000",
"background_color": "#FFFF00"
}
},
"label_settings": {
"show_labels_on_canvas": true,
"default_width_mm": 9
}
}
}TypeScript Interfaces
Complete TypeScript type definitions for the Splice harness schema. Use these interfaces for type-safe integration with the Splice data format.
Enums
export enum PartKind {
Connector = 'connector',
Terminal = 'terminal',
Wire = 'wire',
Cable = 'cable',
Assembly = 'assembly',
}
export enum Gender {
Male = 'male',
Female = 'female',
None = 'none',
}
export enum ConnectorShape {
Circular = 'circular',
Rectangular = 'rectangular',
DSub = 'dsub',
TerminalBlock = 'terminal_block',
Ferrule = 'ferrule',
QuickDisconnect = 'quickdisconnect',
Ring = 'ring',
Button = 'button',
Other = 'other',
}
export enum ConductorType {
Solid = 'solid',
Stranded = 'stranded',
}
export enum ConnectionSide {
Left = 'left',
Right = 'right',
}Main Working Harness Structure
export interface WorkingHarness {
bom: Record<string, ExpandedBomItem>; // Key is instance_id (e.g., "X1", "W1", "C1")
data: WorkingData;
harness_id?: string;
revision_id?: string;
}
export interface ExpandedBomItem {
instance_id: string;
part: any; // Full part data (JSON value) - see Part interface structure below
unit: string;
}Parts System
export interface Part {
id: string; // UUID
kind: PartKind;
mpn: string;
manufacturer: string;
description?: string;
img_url?: string;
datasheet_url?: string;
created_at?: string; // ISO datetime
spec?: any;
}
export interface NewPart {
kind: PartKind;
mpn: string;
manufacturer: string;
description?: string;
img_url?: string;
datasheet_url?: string;
}
export interface AddPartDto {
mpn: string;
kind: 'connector' | 'wire' | 'terminal' | 'cable';
unit?: string;
id?: string; // Optional UUID to uniquely identify the part
}
// BOM item stored in database (uses part ID)
export interface BomItem {
part_id: string; // UUID reference
unit: string; // "each", "m", "ft", etc.
}Connector Specifications
export interface ConnectorSpec {
color?: string;
contact_gender?: Gender;
contact_termination?: string;
fastening_type?: string;
features?: string[];
insulation_material?: string;
mounting_type?: string;
operating_temp_f?: string;
pitch_mm?: number;
positions: number;
recommended_contacts?: string;
row_spacing_mm?: number;
rows?: number;
series?: string;
shape?: ConnectorShape;
wire_awg_min?: number;
wire_awg_max?: number;
keying_code?: string;
bridged_positions?: number[][];
// Custom connector fields
is_custom?: boolean;
created_by_user_id?: string;
is_public?: boolean;
is_approved?: boolean | null;
custom_svg?: CustomConnectorSvg;
pin_mapping?: Record<string, any>; // Simple index->pin_number mapping
custom_properties?: Record<string, any>;
}
export interface CustomConnectorSvg {
mate_side: string;
wire_side: string;
}
export interface ConnectorPart extends Part {
kind: PartKind.Connector;
spec: {
connector: ConnectorSpec;
};
}Wire Specifications
export interface WireSpec {
awg?: number;
stranding?: string | null; // e.g., "7/30"
color?: string | null;
stripe?: string | null;
conductor_type: ConductorType;
}
export interface WirePart extends Part {
kind: PartKind.Wire;
spec: {
wire: WireSpec;
};
}Cable Specifications
export interface CableCore {
core_no: number;
awg?: number;
stranding?: string;
color?: string;
conductor_type: ConductorType;
}
export interface CableSpec {
core_count?: number;
shielded?: boolean;
shield_type?: string;
outer_diameter_mm?: number;
voltage_rating?: number;
default_length_m?: number;
jacket_material?: string;
temperature_rating_c?: number;
flexibility?: string;
template_data?: any;
}
export interface CablePart extends Part {
kind: PartKind.Cable;
spec: {
cable: CableSpec;
};
}
export interface CableWithCores extends CablePart {
cores: CableCore[];
}Working Data Structure
export interface WorkingData {
mapping: Record<string, Connection>; // Key is wire/cable instance_id (e.g., "W1", "C1")
connector_positions: Record<string, ConnectorPosition>; // Key is connector instance_id (e.g., "X1", "X2")
wire_anchors: Record<string, WireAnchor>; // Key is "connector1|connector2" (e.g., "X1|X2")
cable_positions?: Record<string, ConnectorPosition>; // Key is cable instance_id
design_notes?: DesignNote[]; // Optional for backward compatibility
name?: string | null;
description?: string | null;
notes?: string | null;
/** @deprecated Use wire_anchors[key].hidden instead. Kept for backward compatibility. */
hidden_bundles?: string[];
}Connection System
export interface Connection {
end1?: ConnectionTermination;
end2?: ConnectionTermination;
label?: string;
length_mm?: number;
}
export interface TerminationRouting {
mode: string; // "auto" or "manual"
waypoints?: WireAnchor[]; // waypoints for this termination
}
export type ConnectionTermination =
| {
type: 'connector_pin';
connector_instance: string;
pin: number;
side: ConnectionSide;
terminal_instance?: string;
routing?: TerminationRouting;
}
| {
type: 'cable_core';
cable_instance: string;
core_no: number;
side: ConnectionSide;
routing?: TerminationRouting;
}
| {
type: 'flying_lead';
termination_type: 'tinned' | 'bare' | 'heat_shrink';
strip_length_mm?: number;
tin_length_mm?: number;
terminal_instance?: string;
routing?: TerminationRouting;
};Position Types
export interface Position {
x: number;
y: number;
width?: number; // Optional width for adjustable blocks
height?: number; // Optional height for adjustable blocks
collapsed?: boolean; // Optional collapse state for connectors/cables
hidden?: boolean; // Optional hidden state for wire bundles
}
export type ConnectorPosition = Position;
export type WireAnchor = Position;
export interface DesignNote {
id: string;
x: number;
y: number;
content: string;
created_at?: string;
width?: number;
}Harness Management
export interface Harness {
id: string;
owner_id: string;
name: string;
description?: string;
is_public: boolean;
share_token?: string;
created_at: string;
modified_at: string;
}
export interface NewHarness {
name: string;
description?: string;
is_public: boolean;
}
export interface RevisionDoc {
bom: Record<string, BomItem>;
data: WorkingData;
}TypeScript Example
const exampleHarness: WorkingHarness = {
bom: {
X1: {
instance_id: 'X1',
part: {
id: '12345678-1234-1234-1234-123456789abc',
kind: 'connector',
mpn: '09-50-1031',
manufacturer: 'Molex',
description: '3 Position Wire to Board Connector',
spec: {
connector: {
positions: 3,
rows: 1,
shape: 'rectangular',
contact_gender: 'female',
pitch_mm: 2.54,
},
},
},
unit: 'each',
},
W1: {
instance_id: 'W1',
part: {
id: '11111111-2222-3333-4444-555555555555',
kind: 'wire',
mpn: 'AWG22-RED',
manufacturer: 'Generic',
description: '22 AWG Stranded Wire, Red',
spec: {
wire: {
awg: 22,
stranding: '7/30',
color: 'red',
conductor_type: 'stranded',
},
},
},
unit: 'ft',
},
},
data: {
mapping: {
W1: {
end1: {
type: 'connector_pin',
connector_instance: 'X1',
pin: 1,
side: 'right',
},
end2: {
type: 'flying_lead',
termination_type: 'tinned',
strip_length_mm: 6,
tin_length_mm: 3,
},
label: 'POWER',
length_mm: 152.4,
},
},
connector_positions: {
X1: { x: 100, y: 200 },
},
wire_anchors: {},
name: 'Example Harness',
description: 'Simple harness example',
},
};JSON Schema
Complete JSON Schema (draft-07) for validating Splice harness data. Use this schema for validation in any language that supports JSON Schema.
Root Schema
{
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "Splice Harness Schema",
"description": "Complete schema for Splice cable harness data structure",
"type": "object",
"properties": {
"bom": {
"type": "object",
"description": "Bill of Materials with expanded part data",
"additionalProperties": {
"$ref": "#/definitions/ExpandedBomItem"
}
},
"data": {
"$ref": "#/definitions/WorkingData"
},
"harness_id": {
"type": "string",
"format": "uuid",
"description": "UUID of the harness if saved"
},
"revision_id": {
"type": "string",
"format": "uuid",
"description": "UUID of the harness revision if saved"
}
},
"required": ["bom", "data"]
}Enum Definitions
{
"PartKind": {
"type": "string",
"enum": ["connector", "terminal", "wire", "cable", "assembly"]
},
"Gender": {
"type": "string",
"enum": ["male", "female", "none"]
},
"ConnectorShape": {
"type": "string",
"enum": [
"circular", "rectangular", "dsub", "terminal_block",
"ferrule", "quickdisconnect", "ring", "button", "other"
]
},
"ConductorType": {
"type": "string",
"enum": ["solid", "stranded"]
},
"ConnectionSide": {
"type": "string",
"enum": ["left", "right"]
},
"TerminationType": {
"type": "string",
"enum": ["tinned", "bare", "heat_shrink"]
}
}BOM Item Definitions
{
"ExpandedBomItem": {
"type": "object",
"properties": {
"instance_id": { "type": "string" },
"part": { "$ref": "#/definitions/Part" },
"unit": { "type": "string" }
},
"required": ["instance_id", "part", "unit"]
},
"Part": {
"type": "object",
"properties": {
"id": { "type": "string", "format": "uuid" },
"kind": { "$ref": "#/definitions/PartKind" },
"mpn": { "type": "string" },
"manufacturer": { "type": "string" },
"description": { "type": "string" },
"img_url": { "type": "string", "format": "uri" },
"datasheet_url": { "type": "string", "format": "uri" },
"created_at": { "type": "string", "format": "date-time" },
"spec": { "type": "object" }
},
"required": ["id", "kind", "mpn", "manufacturer"]
}
}Connector Spec Definition
{
"ConnectorSpec": {
"type": "object",
"properties": {
"color": { "type": "string" },
"contact_gender": { "$ref": "#/definitions/Gender" },
"contact_termination": { "type": "string" },
"fastening_type": { "type": "string" },
"features": { "type": "array", "items": { "type": "string" } },
"insulation_material": { "type": "string" },
"mounting_type": { "type": "string" },
"operating_temp_f": { "type": "string" },
"pitch_mm": { "type": "number" },
"positions": { "type": "integer", "minimum": 1 },
"rows": { "type": "integer", "minimum": 1 },
"series": { "type": "string" },
"shape": { "$ref": "#/definitions/ConnectorShape" },
"wire_awg_min": { "type": "integer" },
"wire_awg_max": { "type": "integer" },
"keying_code": { "type": "string" },
"bridged_positions": {
"type": "array",
"items": { "type": "array", "items": { "type": "integer" } }
},
"is_custom": { "type": "boolean" },
"custom_svg": { "$ref": "#/definitions/CustomConnectorSvg" },
"pin_mapping": { "type": "object", "additionalProperties": true }
},
"required": ["positions"]
}
}Wire and Cable Spec Definitions
{
"WireSpec": {
"type": "object",
"properties": {
"awg": { "type": "integer" },
"stranding": { "type": ["string", "null"] },
"color": { "type": ["string", "null"] },
"stripe": { "type": ["string", "null"] },
"conductor_type": { "$ref": "#/definitions/ConductorType" }
},
"required": ["conductor_type"]
},
"CableSpec": {
"type": "object",
"properties": {
"core_count": { "type": "integer" },
"cores": { "type": "array", "items": { "$ref": "#/definitions/CableCore" } },
"shielded": { "type": "boolean" },
"shield_type": { "type": "string" },
"outer_diameter_mm": { "type": "number" },
"voltage_rating": { "type": "number" },
"default_length_m": { "type": "number" },
"jacket_material": { "type": "string" },
"temperature_rating_c": { "type": "number" },
"flexibility": { "type": "string" }
}
},
"CableCore": {
"type": "object",
"properties": {
"core_no": { "type": "integer" },
"core_designation": { "type": ["string", "null"] },
"awg": { "type": ["integer", "null"] },
"stranding": { "type": ["string", "null"] },
"core_color": { "type": ["string", "null"] },
"conductor_type": { "$ref": "#/definitions/ConductorType" }
},
"required": ["core_no"]
}
}Working Data Definition
{
"WorkingData": {
"type": "object",
"properties": {
"mapping": {
"type": "object",
"description": "Wire/cable connections mapping",
"additionalProperties": { "$ref": "#/definitions/Connection" }
},
"connector_positions": {
"type": "object",
"description": "Connector positions on canvas",
"additionalProperties": { "$ref": "#/definitions/Position" }
},
"wire_anchors": {
"type": "object",
"description": "Wire routing anchor points",
"additionalProperties": { "$ref": "#/definitions/Position" }
},
"cable_positions": {
"type": "object",
"description": "Cable positions on canvas",
"additionalProperties": { "$ref": "#/definitions/Position" }
},
"design_notes": {
"type": "array",
"items": { "$ref": "#/definitions/DesignNote" }
},
"bundle_labels": {
"type": "object",
"description": "Labels for connectors and cables",
"additionalProperties": { "$ref": "#/definitions/BundleLabel" }
},
"name": { "type": ["string", "null"] },
"description": { "type": ["string", "null"] },
"notes": { "type": ["string", "null"] }
},
"required": ["mapping", "connector_positions", "wire_anchors"]
}
}Connection Definition
{
"Connection": {
"type": "object",
"properties": {
"end1": { "$ref": "#/definitions/ConnectionTermination" },
"end2": { "$ref": "#/definitions/ConnectionTermination" },
"label": { "type": "string" },
"length_mm": { "type": "number" }
}
},
"ConnectionTermination": {
"type": "object",
"properties": {
"type": {
"type": "string",
"enum": ["connector_pin", "cable_core", "flying_lead"]
}
},
"required": ["type"]
},
"Position": {
"type": "object",
"properties": {
"x": { "type": "number" },
"y": { "type": "number" },
"width": { "type": "number" },
"height": { "type": "number" },
"collapsed": { "type": "boolean" },
"hidden": { "type": "boolean" }
},
"required": ["x", "y"]
}
}JSON Example
{
"bom": {
"X1": {
"instance_id": "X1",
"part": {
"id": "12345678-1234-1234-1234-123456789abc",
"kind": "connector",
"mpn": "09-50-1031",
"manufacturer": "Molex",
"description": "3 Position Wire to Board Connector",
"spec": {
"connector": {
"positions": 3,
"rows": 1,
"shape": "rectangular",
"contact_gender": "female",
"pitch_mm": 2.54
}
}
},
"unit": "each"
},
"W1": {
"instance_id": "W1",
"part": {
"id": "11111111-2222-3333-4444-555555555555",
"kind": "wire",
"mpn": "AWG22-RED",
"manufacturer": "Generic",
"description": "22 AWG Stranded Wire, Red",
"spec": {
"wire": {
"awg": 22,
"stranding": "7/30",
"color": "red",
"conductor_type": "stranded"
}
}
},
"unit": "ft"
}
},
"data": {
"mapping": {
"W1": {
"end1": {
"type": "connector_pin",
"connector_instance": "X1",
"pin": 1,
"side": "right"
},
"end2": {
"type": "flying_lead",
"termination_type": "tinned",
"strip_length_mm": 6,
"tin_length_mm": 3
},
"label": "POWER",
"length_mm": 152.4
}
},
"connector_positions": {
"X1": { "x": 100, "y": 200 }
},
"wire_anchors": {},
"name": "Example Harness",
"description": "Simple harness example"
}
}Python API (splice-py)
The splice-py Python library enables programmatic generation of cable harness designs, perfect for automation, batch processing, and integration with existing engineering workflows.
Installation
pip install splice-pyQuick Example
from splice import Harness
harness = Harness(name="Power Distribution")
harness.add_connector(instance_id="X1", mpn="1-480698-0", positions=4)
harness.add_wire(instance_id="W1", mpn="UL1007-18-RED", awg=18)
# Export to JSON or upload directly
json_output = harness.to_json()
result = harness.upload(api_key="your-api-key")Full Documentation
For complete API reference, examples, and usage guides:
Getting Your API Key
To upload harnesses programmatically, you need an API key from your Account Settings page.
Embed Library (@splice-cad/embed)
The @splice-cad/embed JavaScript library allows you to embed interactive Splice harness diagrams directly on your website, documentation, or web application.
Installation
<script src="https://cdn.jsdelivr.net/npm/@splice-cad/embed@0.1.0-beta.2/dist/splice-embed.iife.js"></script>Quick Example
<div id="harness-container"></div>
<script>
Splice.embed('harness-container', 'your-harness-id');
</script>Full Documentation
For complete API reference, configuration options, and examples:
Sharing Harnesses
To embed a harness:
- Public harnesses: Use the harness ID directly
- Private harnesses: Generate a share token from harness settings and pass it via the
tokenoption
Share tokens can be generated from any harness's settings menu.