Documentation
Complete documentation for Splice cable harness design software
Harness Builder
Learn how to design cable harnesses with the visual builder
9 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
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, wires, or cable cores - and move, auto-route, or delete them in a single action.
Selection Methods
- Box Selection: Choose "Box Select" from the top menu bar or right-click on the canvas and select "Box Select," then drag a marquee to encompass items.
- Ctrl-Click Multi-Select: Hold Ctrl (or Cmd) and click individual items to add or remove them from the selection.
Group Dragging & Actions Menu
When items are selected, their drag handles turn blue. Drag any handle to reposition the entire group.
- Select via box-select or Ctrl-click.
- Observe blue handles on each selected item.
- Drag any handle to move the whole selection.
After selection, use the Selection Menu at the bottom of the screen to:
- Auto-route selected wires & cable cores
- Delete selected components
- Copy and paste connectors and or 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:
- Power Supply: AC/DC power supplies, converters
- Circuit Breaker: Resettable protection devices
- Relay: Electromechanical switches
- Contactor: High-power relays for motor control
- Fuse: Overcurrent protection devices
- Switch: Manual toggle or selector switches
- Push Button: Momentary contact switches
- Fan: Cooling fans with wire connections
- Motor: Electric motors
- Timer: Time-delay relays and timers
- PCB: Printed circuit boards
- Splice: Butt splices and wire joins
- Generic: Any other component type
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.
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.