Label Printing Integrations

Tempo label printing integrations

*PACKAGE NOTE:
Tempo label printing integrations use the Printing and Events capabilities available in your Tempo Manufacturing Cloud package. The available printing triggers vary by package and configuration; the options displayed in your environment determine what is available.

*TEMPO 8.0 AVAILABILITY:
The web execution Print on Scan, Create Label printing and material context, and Sample printing capabilities described in this article are planned for the Tempo 8.0 release and are not available until that release is deployed. Existing printing triggers and event integrations continue to follow the package and environment availability described below.

Tempo can send label data to NiceLabel, BarTender, an ERP middleware service, or another printing service. Tempo supplies the event data and identifies the printer. The external printing system supplies the label template, maps the data to template variables, and sends the job to the physical printer.

This article uses NiceLabel and Loftware terminology as an example. The same Tempo configuration pattern applies to other label systems when they can receive a REST, RabbitMQ, or MQTT event and map the payload to a template.

This article is composed of the following topics:

• How Tempo printing works
• Choose a NiceLabel and Loftware deployment
• Configure a NiceLabel integration
• Configure a BarTender integration
• Map Tempo data to label fields
• Read and use JSON dot notation
• Common label types
• Troubleshoot printing

How Tempo printing works

The end-to-end flow is:

Tempo execution or inventory event → Tempo Event Configuration → Event Queue Endpoint → NiceLabel/Loftware or middleware → label template → physical printer

Tempo does not need to contain the NiceLabel or BarTender template file. Instead, Tempo sends a JSON payload containing the selected event data. The downstream printing system uses the payload to:

• select the template;
• map fields such as batch, material, lot, equipment, quantity, and date;
• select the printer; and
• print the requested quantity.

The payload is event-specific. A material sublot event does not contain the same fields as an equipment event, so select the printing trigger that represents the object or action being labeled.

Choose a NiceLabel and Loftware deployment

NiceLabel is now part of the Loftware product family. Loftware Automation Manager is required for the Cloud Trigger architecture described in this article, because Cloud Trigger forwards the request to a local Automation server, which opens the label, maps the variables, and sends the job to a local or network printer.

It is not required for every Loftware/NiceLabel printing architecture. Choose the deployment based on where the printer is located and whether printing must happen automatically or through a user-facing client.

Option 1: Cloud Trigger with Automation Manager

Use this option when Tempo needs to initiate printing to ordinary local or network printers without requiring an inbound connection from Tempo into the plant network. The requirements are:

• Loftware Automation installed and running as the local print/integration service;
• a Cloud Trigger defined in Automation Builder and deployed to Automation Manager;
• printer drivers installed on the computer running Automation;
• a label template in Loftware document storage or another location accessible to Automation;
• an outbound connection from Automation to the Loftware Cloud services; and
• the Cloud Trigger URL and subscription key configured in the Tempo Event Queue Endpoint.

Loftware describes Cloud Trigger as a server-based proxy that forwards cloud requests to an on-premises Automation server.

Option 2: Cloud Print API with a cloud-connected printer

Use this option when the printer itself is compatible with Loftware Cloud Print and can connect to Loftware Cloud. In this design, Tempo does not call a Cloud Trigger and no Automation Manager is needed for the cloud-connected printer.

Tempo can call the Loftware Cloud Print API directly. In this setup, Event Queue Endpoint is the name of the Tempo configuration object; it does not mean that the endpoint is hosted by Tempo. Set the endpoint's Queue URL to the Loftware Cloud Print API URL, so the flow is:

Tempo Event Configuration → Tempo REST Event Queue Endpoint → Loftware Cloud Print API → cloud-connected printer

The requirements are:

• a Loftware Cloud subscription with the Cloud Print add-on/API enabled;
• a supported cloud-connected printer registered in Loftware Control Center;
• the label template stored in Loftware Cloud document storage;
• a Developer Portal subscription key; and
• a Tempo REST Event Queue Endpoint whose Queue URL is the Loftware Cloud Print API endpoint;
• an API-key header configured for the selected API version. For the v1 direct Print API, the current NiceLabel Cloud guide uses Ocp-Api-Subscription-Key; and
• an event body that matches the Cloud Print API contract.

The Cloud Print API payload is different from the Cloud Trigger payload. A Cloud Print request identifies the printer device, document-storage path, quantity, and label data sources. The following is a simplified v2-style target shape; confirm the exact schema in the Developer Portal for the API version enabled for the account:

{
  "deviceType": "CloudPrinter",
  "deviceId": {
    "printerName": "Warehouse_012B",
    "workstation": null
  },
  "filePath": "/Tempo/DispenseLabel.nlbl",
  "fileRevision": "",
  "quantity": "1",
  "dataSources": [
    {
      "BATCH_ID": "BR-2026-0042",
      "MATERIAL_ID": "MAT-1001",
      "LOT_ID": "LOT-7788"
    }
  ]
}

The Loftware documentation identifies the direct-print URL in this form:

https://labelcloudapi.onnicelabel.com/Print/v1/Print/{printerName}

For that v1 direct Print API, the body uses the v1 shape rather than deviceType and deviceId because the printer is supplied in the URL:

{
  "FilePath": "/Tempo/DispenseLabel.nlbl",
  "FileVersion": "",
  "Quantity": 1,
  "Variables": [
    {
      "BATCH_ID": "BR-2026-0042",
      "MATERIAL_ID": "MAT-1001",
      "LOT_ID": "LOT-7788"
    }
  ],
  "PrinterSettings": ""
}

Use the exact URL, header names, and body schema exposed by your Loftware Developer Portal. Do not mix the v1 URL/body contract with the v2 contract.

Tempo can send a custom printing event body, but the standard Cloud Trigger starter template should not be sent unchanged to Cloud Print API. The event configuration must be designed around the Cloud Print API schema, and the printer registered in Tempo must represent the printer identifier expected by that API. If the selected API puts the printer name in the URL, each printer may require its own endpoint configuration because Tempo's Queue URL is a configured destination, not a per-event template.

For a REST Event Configuration, turn Include Printing Metadata off unless the selected Cloud Print API contract explicitly accepts an additional top-level Metadata property. When enabled, Tempo adds metadata to the outgoing body; the standard Cloud Print API request schema does not document that property.

Cloud Print can also target a non-cloud PrintQueue, but that path still depends on a connected Loftware workstation and printer driver. If the goal is to remove all local Loftware software, use a compatible cloud-connected printer.

What this means for the Tempo setup

The NiceLabel steps below are specifically for Cloud Trigger with Automation Manager. To use Cloud Print API instead, keep the Tempo Event Configuration concept but replace the Cloud Trigger URL, payload template, and printer registration with the Cloud Print API contract.

See Loftware's Cloud Trigger, Cloud Print API, and direct integrations documentation for the provider-side requirements.

Configure a NiceLabel integration

1. Prepare NiceLabel and Loftware Cloud Trigger

1. Sign in to the Loftware Control Center and confirm that document storage is available for label templates.

2. Create or update the label in NiceLabel Designer.

3. Create variables in the label that correspond to the JSON properties that Tempo will send.

4. Save the label file in Loftware document storage and record its full path, for example:

   /Projects/Tempo-Label/DispenseLabel.nlbl
   

5. Install Loftware Automation on the computer that can reach the label printer. Use NiceLabel Designer wherever the label template is authored or maintained.

6. Open NiceLabel Automation Builder and create a Cloud Trigger configuration. Configure the trigger to:

   1. accept the JSON data received from Tempo;
   2. parse the JSON fields with a JSON Data Filter;
   3. open the label file;
   4. set the printer; and
   5. print the requested quantity.

7. Deploy the configuration to Loftware Automation Manager and confirm that the Automation Manager service is running.

2. Create the Tempo Event Queue Endpoint

1. In Tempo, navigate to Platform > Team Integrations > Events > Event Queue Endpoints.

2. Click Create New Configuration.

3. Enter the endpoint information:

   1. Queue Name: Enter a recognizable name, such as NiceLabel.

   2. Queue URL: Enter the URL for the NiceLabel Cloud Trigger. A typical Loftware URL has this form:

      https://labelcloudapi.onnicelabel.com/Trigger/v1/CloudTrigger/{TriggerName}
      

   3. Endpoint Type: Select REST.

   4. Authorization Type: Select API Key.

   5. API Name: Enter the header name supplied by Loftware, such as Ocp-Apim-Subscription-Key.

   6. API Token: Enter the subscription token supplied by Loftware.

4. Click Save.

The API token is stored as a secret. When editing an existing endpoint, a saved token is represented by a masked value; leaving it unchanged keeps the existing secret.

3. Create the Tempo printing event

1. Navigate to Platform > Team Integrations > Events > Event Configuration.

2. Click Create New Event Configuration.

3. On the Event Info tab, enter or select:

   1. Queue Endpoint: Select the NiceLabel endpoint that you created.
   2. Name: Enter a descriptive name, such as Dispense Label.
   3. Event Type: Select Printing.
   4. Event Trigger: Select the event that matches the label purpose. Review Common label types.
   5. Active: Leave the event active when it is ready for use.

4. Open the Output Configuration tab.

5. Review the prepopulated JSON template for the selected event trigger.

6. Update the JSON to contain only the properties needed by the label provider, or rename output properties to match the receiving system. Keep the Tempo substitution expressions accurate.

7. Leave Include Printing Metadata enabled unless the receiving system explicitly requires a payload without metadata.

8. Click Add. When editing an existing configuration, click Save.

Tempo requires the printing output to be valid JSON. The event configuration is not usable until its referenced endpoint, event body, and event trigger are valid and active.

4. Register the printer in Tempo

1. Navigate to Platform > Team Integrations > Printers.

2. Click Register New Printer.

3. Enter:

   1. Printer Name: Use the exact printer name registered in Loftware Control Center or in the middleware. Printer names are case-sensitive.
   2. Serial Number: Enter the printer serial number.
   3. Location: Select the printer location when location information is part of the payload or required by your operating process.

4. Click Add.

The printer selected during execution is included in the printing payload. NiceLabel Automation can use the printer name from that payload to route the job to the correct local printer.

5. Connect the event to a Tempo workflow

The last setup step depends on when the label should print:

• For web execution Print on Scan for equipment or material sublots, use the corresponding printing event configuration when the operator selects Print Label. This capability is planned for Tempo 8.0.
• For a dispense or material output, configure the material action to require a label when appropriate. If your environment provides the authoring fields, select Label Event Configuration and enter Print Quantity. The selected configuration must use the matching Dispense or Material Output trigger.
• For a procedure Create Label action, configure the Create Label printing event and use the action's label rows and material binding to determine the label content. Create Label printing is planned for Tempo 8.0.
• For a sample or kit, use the matching Sample or Create Kit event configuration. Sample printing is planned for Tempo 8.0; Create Kit follows the package and environment availability shown in the table.

When more than one active configuration exists for the same label type, the operator can select the appropriate label configuration during execution unless the procedure has preselected one.

Configure a BarTender integration

Tempo does not contain a BarTender-specific adapter. In practice, there are two common BarTender options:

BarTender Cloud: transform the request to the Cloud action format

The BarTender Cloud Actions API has its own action contract. In current REST JSON examples, its print action uses values such as Document, Printer, Copies, and optionally NamedDataSources, DatabaseOverrides, or query prompts. The provider's YAML action reference names the corresponding document property DocumentFile; use the schema for the API surface being called. The Actions API supports action requests in JSON or YAML.

When Include Printing Metadata is enabled for a REST Event Configuration, Tempo adds a top-level Metadata property to the outgoing JSON body. The body is effectively:

{
  "<Tempo event fields>": "...",
  "Metadata": {
    "EventType": "Printing",
    "EventTrigger": "printing_dispense",
    "OrganizationID": "...",
    "CreationDateTime": "..."
  }
}

Metadata is Tempo transport context; it is not a BarTender Cloud PrintBTWAction property. Therefore, a metadata-enabled Tempo event should not be sent to the Cloud Actions API as though it were already a BarTender action request. Use one of these approaches:

1. Turn off Include Printing Metadata for the Event Configuration and shape the printing JSON itself as a BarTender Cloud action request, if the Tempo event body and provider contract can be aligned.
2. Send the normal Tempo event to middleware that removes or ignores Metadata, maps the event fields to BarTender Cloud NamedDataSources or database input, and submits the Cloud action request.

Disabling metadata alone does not automatically convert the rest of the Tempo payload into the BarTender Cloud action format. The label document must also be stored in the Cloud Librarian location, the printer value must use the BarTender Cloud printer identifier, and the Cloud API credentials and permissions must be configured.

For example, this is the kind of request the BarTender Cloud API expects after the Tempo data has been mapped. It is an illustrative target body, not a copy-and-paste Tempo Event Configuration:

[
  {
    "PrintBTWAction": {
      "Document": "librarian://Main/Tempo/Dispense.btw",
      "Printer": "printer:printserver/Zebra_110Xi4(300_dpi)",
      "Copies": "1",
      "NamedDataSources": {
        "BatchNumber": "BR-2026-0042",
        "MaterialNumber": "MAT-1001",
        "LotNumber": "LOT-7788",
        "Quantity": "25",
        "UnitOfMeasure": "kg"
      }
    }
  }
]

The Cloud printer identifier has provider-specific formatting. Do not assume that the friendly printer name registered in Tempo is sufficient; register the value that the Cloud API expects, or have middleware translate the Tempo printer name.

BarTender Integration Builder: receive the Tempo event and print locally

Integration Builder is a better fit when the printers are local or when the incoming Tempo event needs more transformation. Configure a BarTender web-service integration that accepts the REST POST from Tempo, then:

1. Configure the Integration Builder web-service endpoint and authentication.
2. Register that endpoint in Tempo under Platform > Team Integrations > Events > Event Queue Endpoints using REST.
3. Configure the Tempo Event Configuration with Event Type: Printing, the appropriate printing trigger, and the starter JSON for that trigger.
4. In Integration Builder, use the incoming event data as the input to the integration. Map fields such as BatchRun, MaterialDefinition.DefinitionID, MaterialLot.Number, MaterialSublot.Name, Quantity, and UnitOfMeasure to BarTender named data sources, query prompts, or a record set.
5. Add a Print Document action. Select the .btw document, use the incoming data as the data source, map the printer and copy count, and configure the response or verification behavior.
6. Confirm the BarTender service can access the document and the local printer, then test the complete request path.

Integration Builder can handle the Tempo event envelope in its input and transformation steps. Metadata is normally used for logging or routing and does not need to become a label field. If the integration is configured to accept only a strict field list, turn off Include Printing Metadata or explicitly ignore the Metadata property.

The Integration Builder path is:

Tempo Event Configuration → BarTender web-service integration → input/data mapping → Print Document → local printer

See Seagull Scientific's BarTender Cloud Actions API, Integration Builder web-service integrations, and Print Document action documentation for the provider-side configuration.

Map Tempo data to label fields

Use the event-specific template

Tempo displays a starter JSON template for each printing trigger. Expressions in the form &{{Name}} tell Tempo to substitute a value when the event is sent. Some values are objects rather than simple text values. For those values, the external printing system can map a nested property with dot notation.

For example, a material value can contain a nested material definition. A middleware mapping can use a path such as:

MaterialLot.MaterialDefinition.UnitOfMeasure

The property name sent to the receiving system does not have to match the Tempo source name, but the substitution expression must point to the correct Tempo value. If a property is renamed, update the label-provider mapping at the same time.

Read and use JSON dot notation

Dot notation reads a value inside nested JSON objects from left to right. Each dot moves down one object level:

MaterialLot.MaterialDefinition.DefinitionID
└─ MaterialLot
   └─ MaterialDefinition
      └─ DefinitionID

Given this JSON:

{
  "MaterialLot": {
    "Number": "LOT-7788",
    "MaterialDefinition": {
      "DefinitionID": "MAT-1001",
      "DefinitionName": "Cleaning Solution",
      "UnitOfMeasure": "kg"
    }
  },
  "MaterialSublot": {
    "Name": "SL-0007",
    "QCStatus": "Released"
  },
  "BatchRun": "BR-2026-0042"
}

These paths resolve as follows:

Tempo expressions versus receiver paths

There are two related but different paths to understand:

1. Tempo substitution expression: In the Event Configuration JSON, &{{...}} tells Tempo which value to insert. For example:

   {
     "MaterialNumber": "&{{MaterialDefinition.DefinitionID}}",
     "LotNumber": "&{{MaterialLot.Number}}",
     "EquipmentID": "&{{ID}}",
     "BatchNumber": "&{{BatchRun}}"
   }
   

2. Receiver mapping path: After Tempo sends the event, NiceLabel, BarTender, or middleware maps the received JSON path to a template variable. If the fields are inside Variables[0], the receiver may use a path such as Variables[0].MaterialLotNumber. The exact array syntax depends on the receiving product; some tools expose the first array item as a record rather than using [0].

The two paths do not have to be identical. For example, this Tempo configuration:

{
  "Variables": [
    {
      "BatchNumber": "&{{BatchRun}}",
      "MaterialNumber": "&{{MaterialDefinition.DefinitionID}}",
      "LotNumber": "&{{MaterialLot.Number}}"
    }
  ]
}

can produce:

{
  "Variables": [
    {
      "BatchNumber": "BR-2026-0042",
      "MaterialNumber": "MAT-1001",
      "LotNumber": "LOT-7788"
    }
  ]
}

The label provider then maps Variables[0].BatchNumber to its BatchNumber variable, Variables[0].MaterialNumber to its MaterialNumber variable, and so on.

Common Tempo path examples

The following expressions are present in Tempo's standard printing templates. Use only paths supported by the selected trigger:

&{{BatchRun}}
&{{ProcedureRun}}
&{{ProcessAction}}
&{{MaterialSublot.MongoID}}
&{{MaterialSublot.Name}}
&{{MaterialLot.Number}}
&{{MaterialLot.ExpirationDate}}
&{{MaterialDefinition.DefinitionID}}
&{{MaterialDefinition.DefinitionName}}
&{{MaterialDefinition.UnitOfMeasure}}
&{{ID}}                 Equipment ID or material sublot ID, depending on trigger
&{{printer.name}}       Registered printer name
&{{CurrentDate}}        Print date/time

For a Create Label event, the standard template exposes separate material objects, so a material number is typically &{{MaterialDefinition.DefinitionID}}. For a Material Sublot or Dispense event, the template may provide a complete MaterialLot object and event-specific fields such as Quantity and UnitOfMeasure. If the provider needs a leaf value, either map the nested object in the provider or change the Tempo output to reference the leaf property explicitly.

Mapping custom properties

Tempo sends CustomProperties as an array of property objects. Each item contains a property name and value, and may also contain a unit of measure. For example:

{
  "MaterialDefinition": {
    "CustomProperties": [
      {
        "Name": "StorageClass",
        "Value": "Cold",
        "UnitOfMeasure": ""
      }
    ]
  }
}

Because this is an array, mapping the actual property name as though it were an object key does not work:

MaterialDefinition.CustomProperties.StorageClass  // does not resolve

Tempo can address an array item by its numeric position:

MaterialDefinition.CustomProperties[0].Value  // resolves to "Cold" in this example

However, array order should not be treated as the identity of a custom property. The position can change when properties are added or reordered. For a reliable mapping, configure NiceLabel, BarTender, or middleware to iterate over CustomProperties, find the item whose Name is StorageClass, and map its Value to the label field. If the selected label system cannot filter the array by Name, transform the payload before printing:

{
  "StorageClass": "Cold"
}

The standard Create Label template exposes the complete array through MaterialCustomProperties, MaterialLotCustomProperties, and MaterialSublotCustomProperties. These Create Label material-context fields, including custom properties, are planned for Tempo 8.0. Tempo's substitution syntax supports nested paths and array indexes, but it does not provide a name-based lookup such as “find the array item whose Name equals StorageClass.” If a custom property can be absent, define how the label should display the missing value before enabling the print process.

Dot-notation troubleshooting

• A path is case-sensitive. MaterialLot.Number and MaterialLot.number are different paths.
• A path only works when the selected event supplies that object. An Equipment event does not automatically contain material-lot data.
• An object path and a leaf path produce different values. MaterialLot may produce an object; MaterialLot.Number produces one text value.
• Arrays need special handling. Confirm whether the provider expects Variables[0].Field, Variables.0.Field, or a record mapping.
• If the receiver sees the literal text &{{MaterialLot.Number}}, the Tempo substitution was not applied or the path is not available for that trigger.
• Capture the actual event payload before changing the label template. First confirm the value exists, then correct the mapping.

Common field mappings

The exact source path depends on the event trigger. To avoid printing the wrong value, capture one representative payload for the exact event and map the label variables from that payload. Do not assume that a field called BatchNumber, MaterialNumber, or EquipmentID exists in every trigger; the starter template and sample payload establish the available data.

Example payload pattern

The following is a simplified pattern. The actual fields available inside Variables depend on the selected printing trigger.

{
  "LabelName": "&{{LabelName}}",
  "Quantity": "&{{PrintQuantity}}",
  "Printer": "&{{printer.name}}",
  "Variables": [
    {
      "BatchRun": "&{{BatchRun}}",
      "MaterialDefinitionID": "&{{MaterialDefinition.DefinitionID}}",
      "MaterialLotNumber": "&{{MaterialLot.Number}}",
      "EquipmentID": "&{{ID}}",
      "PrintDateUTC": "&{{CurrentDate}}"
    }
  ]
}

Use only fields supported by the selected event. For example, EquipmentID belongs in an Equipment event; a Material Sublot event should use its material and sublot fields instead.

Create Label content

The Create Label trigger provides the content authored in the Create Label process action, including the label QR data and the two configured label rows. When the action is bound to a material sublot, the event can also provide material sublot, material lot, and material definition context. This makes Create Label useful for a label whose text is assembled from procedure values as well as standard material data. Create Label printing and this material context are planned for Tempo 8.0.

Common label types

Tempo's printing triggers map to the label categories that teams most commonly use. Package availability is shown as a general guide; the options displayed in your environment are authoritative.

The label design itself is usually one of these practical forms:

• an identification label containing a human-readable identifier and barcode or QR code;
• a material or lot label containing identity, quantity, unit, status, dates, and storage location;
• a process label containing batch, procedure, operation, step, and operator information;
• an equipment label containing equipment ID, serial number, model, and calibration or status information;
• a sample or kit label containing the object identifier and its related metadata; or
• an ERP, shipping, or site-specific label whose format is controlled by an ERP, warehouse system, or dedicated middleware service.

Troubleshoot printing

The event is not available during execution

• Confirm that the Event Configuration is Active.
• Confirm that its Event Trigger matches the object or action being printed.
• Confirm that the printer is active and that the operator has the required permissions.
• For material actions, confirm that the selected authored label configuration still exists and uses the correct trigger.

The endpoint receives a request but the label is blank

• Capture the actual payload for the exact event trigger.
• Compare the label variables with the JSON property names and nested paths in the payload.
• Confirm that the substitution expression uses the correct Tempo source, such as MaterialLot.Number rather than an assumed MaterialNumber field.
• Confirm that dates and quantities are mapped using the format expected by the label provider.
• Validate the JSON in Output Configuration before saving.

NiceLabel receives the event but does not print

• Confirm that Loftware Automation Manager is running and that the latest configuration is deployed.
• Confirm that the Cloud Trigger identifier in the URL is correct.
• Confirm that the label file path in Open Label matches the path in Loftware document storage.
• Confirm that the printer name in Tempo matches the Loftware printer name exactly, including capitalization.
• Confirm that the Set Printer action maps the received printer value and that the Print Label action maps the requested quantity.

Next steps

• To configure standard NiceLabel Cloud integrations, review the Loftware Cloud Integrations documentation.
• To review direct integration options, review the Loftware Cloud direct integrations documentation.
• For a different label provider, keep the Tempo event and data-mapping steps and replace the NiceLabel Cloud Trigger, template, and printer-routing steps with the equivalent provider configuration.