Sequence API

Create, read, update, delete, and launch sequences of steps on Big Block.

Overview

Big Block supports sequences of steps. A Sequence is a series of customized Steps that describe which devices (or locations) should activate and with what messages. Steps can activate concurrently or sequentially, and acknowledgement of a Step automatically advances the Sequence to the next Step.

Tip

The Sequencer is designed for companies that do not have IT bandwidth/resources. It lets Big Block handle real-time response to button presses, reducing the complexity of your integration code.

Endpoint Reference

Base URL: https://www.voodoodevices.com/api/

Method	Endpoint	Description
GET	`/sequence/`	List all sequences (unstarted, in-progress, completed)
POST	`/sequence/`	Create a new sequence
GET	`/sequence/{seqID}/`	Retrieve a specific sequence with all steps
PUT	`/sequence/{seqID}/`	Update an existing sequence (replace steps)
DELETE	`/sequence/{seqID}/`	Delete a sequence
GET	`/launchsequence/{seqID}/`	Launch or relaunch a stalled sequence

OpenAPI Specification

OAS 3.0

This API is fully OpenAPI Specification (OAS 3.0) compliant. The machine-readable spec unlocks powerful integrations:

Postman: use Import → Link and paste the spec URL — all endpoints, parameters, and example bodies load automatically.
AI coding tools (GitHub Copilot, Cursor, ChatGPT, etc.): paste the spec URL and they generate accurate, working client code with correct field names and auth headers.
SDK generators: produce typed clients in any language with tools like openapi-generator or fern.

Spec URL:

https://bblock-demo.voodoorobotics.com/sequence/openapi.json

Step Parameters

Each step in a sequence can include the following parameters:

Parameter	Type	Description
`order`	int	Execution order. Steps with the same value run concurrently.
`device`	string	DeviceID to target (e.g., "CAE96B:5DC841")
`location`	string	Location name (alternative to device; uses super-string matching)
`command`	string	Action to trigger (e.g., "flash")
`line1–line5`	string	Up to 5 lines of display text (max 26 chars each)
`arrow`	string	Direction arrow: left, right, top, bottom, topleft, topright, bottomleft, bottomright
`color`	string	LED color: r (red), g (green), b (blue), etc.
`sound`	string	Sound pattern (e.g., "15,c5,4")
`barcode`	string	Barcode string to display
`quantity`	int	Quantity to display in a box (0–63)
`seconds`	int	Timeout in seconds before the step times out
`stepnonce`	string	Unique tag sent to feedback server on ACK/NACK

Sequence-Level Parameters

Parameter	Type	Description
`sequenceid`	string	Unique identifier for the sequence
`sequencenonce`	string	Unique tag sent to feedback server after the last step is acknowledged
`steps`	array	Array of step objects (see step parameters above)

Execution Model

Order of Execution

Steps execute in sequential order based on their order value. Steps with the same order value run concurrently after all previous steps are acknowledged.

Device vs. Location

Each step can specify either a device directly or alocation name. If a location is specified, the system uses super-string matching to find the first device associated with that location.

Acknowledgement & Nonce Handling

stepnonce is a unique tag sent to a feedback server when a step is acknowledged (ACK) or times out (NACK). sequencenonce is sent after the last step is acknowledged.

Timeout Handling

Each step includes a seconds parameter specifying how long to wait before timing out. A timeout halts the entire sequence until the issue is resolved.

Setup

import requests
import json

url = 'https://www.voodoodevices.com/api/'
api_key = 'your_api_key'
headers = {'API-KEY': api_key}

List All Sequences

def allSequences():
    """Retrieve all sequences (unstarted, in-progress, completed)."""
    response = requests.get(url + "sequence/", headers=headers)
    return response.json()

print(json.dumps(allSequences(), indent=4))

Create a Sequence

def createSequence(seqID):
    """Create a new sequence with steps."""
    sequence_data = {
        "sequenceid": seqID,
        "sequencenonce": seqID + "Order 314 Completed",
        "steps": [
            {
                "order": 1,
                "device": "CAE96B:5DC841",
                "command": "flash",
                "line1": "Take 4",
                "line2": "of SKU 984-534",
                "arrow": "left",
                "seconds": 300
            },
            {
                "order": 2,
                "location": "Warehouse Display",
                "command": "flash",
                "line1": "Betty",
                "line2": "PICK",
                "barcode": "SKU 567-554",
                "quantity": 36,
                "seconds": 300,
                "color": "g"
            },
            {
                "order": 2,
                "device": "D59094:AD433B",
                "command": "flash",
                "line1": "Betty",
                "line2": "PICK",
                "barcode": "SKU 443-222",
                "quantity": 8,
                "seconds": 300,
                "color": "b"
            },
            {
                "order": 4,
                "device": "D255D3:3A17E8",
                "command": "flash",
                "line1": "Pick",
                "barcode": "SKU 563-559",
                "arrow": "left",
                "quantity": 4,
                "seconds": 30,
                "stepnonce": "Item|4|completed",
                "sound": "15,c5,4"
            }
        ]
    }
    requests.post(url + "sequence/", headers=headers, json=sequence_data)

createSequence("Test_3")

Note

In this example, steps with order: 2 execute simultaneously after step 1 is acknowledged. Step 4 runs only after both order-2 steps are acknowledged.

Read a Sequence

def readSequence(seqID):
    """Retrieve detailed information about a specific sequence."""
    response = requests.get(url + "sequence/" + str(seqID) + "/", headers=headers)
    return response.json()

print(json.dumps(readSequence("Test_3"), indent=4))

Update a Sequence

def updateSequence(seqID):
    """Update an existing sequence by replacing its steps."""
    updated_data = {
        "sequenceid": seqID,
        "sequencenonce": "Order 314: Updated order completed",
        "steps": [
            {
                "order": 5,
                "location": "Warehouse Display",
                "command": "flash",
                "line1": "Betty",
                "line2": "PICK",
                "barcode": "SKU 567-554",
                "quantity": 36,
                "seconds": 300,
                "color": "g"
            },
            {
                "order": 6,
                "device": "D255D3:3A17E8",
                "command": "flash",
                "seconds": 10,
                "stepnonce": "Item|4|completed",
                "sound": "15,c5,4"
            }
        ]
    }
    requests.put(url + "sequence/" + str(seqID) + "/", headers=headers, json=updated_data)

updateSequence("Test_3")

Delete a Sequence

def deleteSequence(seqID):
    """Delete a specified sequence."""
    requests.delete(url + "sequence/" + str(seqID) + "/", headers=headers)

deleteSequence("Test_3")

Launch a Sequence

def launchSequence(seqID):
    """Launch or relaunch a stalled sequence."""
    requests.get(url + "launchsequence/" + str(seqID) + "/", headers=headers)

launchSequence("Test_3")

Tip

The launch endpoint uses a GET request. You can also use it to relaunch a sequence that has stalled due to a timeout.

REST API Overview

Core device endpoints and base URLs

Orders API

Order management and fulfillment tracking

Closed Loop System

Acknowledgements and feedback patterns

Best Practices

Operational guardrails and deployment tips