Example requests

Run these queries and mutations in the API Playground. To send one from your own client, such as an HTTP action in an automation tool, put the operation in the JSON request body’s query field as a string, and its variables in the variables field:

{
  "query": "mutation CancelRun($input: CancelRunInput!) { cancelRun(input: $input) { run { id status } } }",
  "variables": { "input": { "id": 1234, "etag": "etag-from-your-query" } }
}

Queries
Mutations

Search parts

Find parts by part number or description substring:

query SearchParts($q: String!, $first: Int) {
  parts(filters: { partNumber: { ilike: $q } }, first: $first) {
    edges {
      node {
        id
        partNumber
        description
        revision
        partType
        status
        partSubtypes { id name }
      }
    }
  }
}

{ "q": "%BRKT%", "first": 25 }

Get a procedure with all steps

Fetch a procedure template plus every step and its fields:

query GetProcedure($id: Int!) {
  procedure(id: $id) {
    id
    title
    steps {
      id
      title
      fields { id }
    }
  }
}

{ "id": 12 }

Get a run step field's values across runs

Find every recorded value of one field, on run steps with a given title, across runs that build a given part number:

query FieldValuesAcrossRuns($partNumber: String!, $stepTitle: String!, $fieldName: String!, $first: Int) {
  runStepFields(
    filters: {
      name: { eq: $fieldName }
      step: {
        title: { eq: $stepTitle }
        run: { part: { partNumber: { eq: $partNumber } } }
      }
    }
    first: $first
  ) {
    edges {
      node {
        id
        name
        value
        _updated
        updatedBy { id }
        step {
          id
          title
          run {
            id
            title
            partInventory { serialNumber }
          }
        }
      }
    }
  }
}

{ "partNumber": "PN-1000", "stepTitle": "Torque check", "fieldName": "Torque", "first": 100 }

Get an aBOM's build requirements

List the build requirements on a unit’s as-built BOM:

query AbomTree($id: Int!) {
  partInventory(id: $id) {
    id
    serialNumber
    part { partNumber }
    buildRequirements {
      id
      part { partNumber }
      quantity
    }
  }
}

{ "id": 9876 }

Compare two aBOMs

Pull the as-built BOMs of two units and diff them client-side:

query CompareAboms($idA: Int!, $idB: Int!) {
  a: partInventory(id: $idA) {
    id
    serialNumber
    buildRequirements { id part { partNumber } quantity }
  }
  b: partInventory(id: $idB) {
    id
    serialNumber
    buildRequirements { id part { partNumber } quantity }
  }
}

{ "idA": 9876, "idB": 9877 }

List open runs

Get the runs that are to do or in progress. Each run’s _etag is the value an update mutation on that run needs:

query OpenRuns {
  runs(filters: { status: { in: [TODO, IN_PROGRESS] } }, first: 100) {
    edges {
      node {
        id
        _etag
        title
        status
        procedure { id title }
        partInventory { id serialNumber part { partNumber } }
      }
    }
  }
}

Run history for a part

Every run a specific part inventory has gone through, newest first:

query RunHistory($partInventoryId: Int!) {
  runs(
    filters: { partInventoryId: { eq: $partInventoryId } }
    sort: [_CREATED_DESC]
    first: 50
  ) {
    edges {
      node {
        id
        title
        status
        _created
        procedure { id title }
      }
    }
  }
}

{ "partInventoryId": 9876 }

Inventory for a part by location

List inventory units of a given part, with each unit’s location:

query InventoryByLocation($partId: Int!) {
  partInventories(filters: { partId: { eq: $partId } }, first: 250) {
    edges {
      node {
        id
        serialNumber
        lotNumber
        quantity
        status
        location { id name type }
      }
    }
  }
}

{ "partId": 12 }

Serialized units for a part

Get every serialized instance of a part with its current state:

query SerializedUnits($partId: Int!) {
  partInventories(filters: { partId: { eq: $partId } }, first: 250) {
    edges {
      node {
        id
        serialNumber
        status
        location { id name }
      }
    }
  }
}

{ "partId": 12 }

List open issues by disposition

All open issues, with each issue’s disposition type for triage:

query OpenIssuesByDisposition {
  issues(
    filters: { status: { in: [PENDING, IN_PROGRESS, IN_REVIEW] } }
    first: 250
  ) {
    edges {
      node {
        id
        title
        status
        issueDispositionType { id title }
        assignedTo { id name }
        _created
      }
    }
  }
}

List users with their IDs

Match each user’s numeric id to their name and email, such as to fill a setting that asks for user IDs or to read the user IDs in an export:

query Users($after: String) {
  users(first: 100, after: $after) {
    edges {
      node { id name email }
    }
    pageInfo { endCursor hasNextPage }
  }
}

While hasNextPage is true, run the query again with after set to the endCursor from the previous page. For more information, see Paginate query results.

Change history for a part

List the recorded changes to one part, such as edits to its reorder points, with when each change happened, who made it, and the fields it changed:

query PartHistory($partId: Int!) {
  loggedActions(
    filters: { rootTableName: { eq: PARTS }, rootModelId: { eq: $partId } }
    sort: [TIMESTAMP_DESC]
    first: 100
  ) {
    edges {
      node {
        timestamp
        action
        tableName
        changedFields
        user { id name }
      }
    }
  }
}

{ "partId": 12 }

Get current user and org

Verify your token and find which org you’re in:

query Me {
  me {
    id
    name
    email
    organization { id domain }
  }
}

Most update, cancel, and delete mutations take the record’s id and its current etag. Read _etag in the query that finds the records, then pass each record’s value as etag in the mutation’s input. For more information, see Etag-based concurrency.

Create a part

Create a new part in the library:

mutation CreatePart($input: CreatePartInput!) {
  createPart(input: $input) {
    part { id partNumber description revision partType status }
  }
}

{
  "input": {
    "partNumber": "TEST-001",
    "description": "Integration test part",
    "revision": "A",
    "partType": "PART",
    "trackingType": "LOT"
  }
}

Create a run from a procedure

Start a new run by binding a procedure to a part inventory:

mutation CreateRun($input: CreateRunInput!) {
  createRun(input: $input) {
    run {
      id
      title
      status
      procedure { id title }
      partInventory { id serialNumber }
    }
  }
}

{
  "input": {
    "procedureId": 12,
    "partInventoryId": 9876,
    "title": "Build #2026-04-26 Unit 1"
  }
}

Record a run step field value

Set the value of one field on a run step. Pass the run step field’s id and _etag:

mutation RecordFieldValue($input: UpdateRunStepFieldValueInput!) {
  updateRunStepFieldValue(input: $input) {
    runStepField { id name value }
  }
}

{
  "input": {
    "id": 88,
    "etag": "etag-from-your-query",
    "value": "12.45"
  }
}

Complete a run step

Move a run step to complete. A run has no status of its own to set: it rolls up its status from its run steps.

mutation CompleteStep($input: UpdateRunStepInput!) {
  updateRunStep(input: $input) {
    runStep { id status }
  }
}

{
  "input": {
    "id": 4567,
    "etag": "etag-from-your-query",
    "status": "COMPLETE"
  }
}

Update several runs

Change fields on several runs in one request. updateRuns takes a list of run inputs, each with its own id and etag, such as the runs a status-filtered query returned:

mutation UpdateRuns($input: [UpdateRunInput]) {
  updateRuns(input: $input) {
    runs { id title assignedToId }
  }
}

{
  "input": [
    { "id": 1234, "etag": "etag-for-1234", "assignedToId": 42 },
    { "id": 1235, "etag": "etag-for-1235", "assignedToId": 42 }
  ]
}

Cancel a run

Cancel one run. cancelRun takes one run per request, so send it once for each run:

mutation CancelRun($input: CancelRunInput!) {
  cancelRun(input: $input) {
    run { id status }
  }
}

{
  "input": {
    "id": 1234,
    "etag": "etag-from-your-query"
  }
}

Create a purchase order

Create a purchase order for a supplier. Then add each line with createPurchaseOrderLine:

mutation CreatePO($input: CreatePurchaseOrderInput!) {
  createPurchaseOrder(input: $input) {
    purchaseOrder {
      id
      status
      supplier { id name }
    }
  }
}

{
  "input": {
    "supplierId": 42
  }
}

Add a line to a purchase order

Add a part and quantity to an existing purchase order:

mutation AddPOLine($input: CreatePurchaseOrderLineInput!) {
  createPurchaseOrderLine(input: $input) {
    purchaseOrderLine { id quantity part { partNumber } }
  }
}

{
  "input": {
    "purchaseOrderId": 501,
    "partId": 12,
    "quantity": 100
  }
}

Create an issue linked to a run

Open a quality issue tied to a specific run step:

mutation CreateIssue($input: CreateIssueInput!) {
  createIssue(input: $input) {
    issue {
      id
      title
      status
      runStep { id }
    }
  }
}

{
  "input": {
    "title": "Surface scratches on RX-22 lot 4",
    "runStepId": 4567
  }
}

Close an issue with a resolution

Move an issue to resolved once reviews are signed off:

mutation ResolveIssue($input: UpdateIssueInput!) {
  updateIssue(input: $input) {
    issue { id status }
  }
}

{
  "input": {
    "id": 7777,
    "etag": "etag-from-your-query",
    "status": "RESOLVED"
  }
}

Getting Started

Build Hardware

Manage Supply Chain

Track Quality

Automate with ION

Administration

API