ESL Binding API Tutorial: Connect Tags to Items

You have an electronic shelf label tag in your hand and an item in your catalog. You need that tag to show the right price, product name, and additional data without walking through a proprietary handheld workflow. This tutorial shows how to use the ESL Binding API in the Next Generation Label Printing System (LPSNG) to connect an ESL tag to an item through a simple HTTPS call.

By the end, you will be able to programmatically bind a tag from an external system such as a mobile data entry (MDE) unit, verify the binding, and unbind or rebind a tag when it moves to a different item.

Prerequisites

Before you start, make sure you have the following:

• An LPSNG account with access to the ESL Binding API. The binding API is part of the core LPSNG functionality and is available in all editions.
• Compatible ESL hardware that supports the binding interface, for example CATIC ESL devices.
• A powered ESL base station with the tags you want to bind within range.
• Basic familiarity with REST APIs and JSON.
• The base URL for your LPSNG web service, as shown in your account configuration.
• OAuth2 client credentials for authentication. If you have not registered an external system yet, follow the OAuth2 documentation first.

You do not need to talk directly to a vendor-specific base station protocol. The hard way would be to reverse-engineer the low-level communication used by your ESL hardware. The supported path is to let the LPSNG managed service handle that translation while you use one HTTPS API.

Step-by-Step: Binding an ESL Tag to an Item

Step 1: Obtain an OAuth2 Access Token

LPSNG uses a simplified OAuth2 registration protocol for external systems. Once your integration is registered, you request an access token from your tenant token endpoint and include it in every API call.

The exact endpoint and registration flow depend on your account. In most setups, a client credentials request looks like this:

curl -s -X POST "https://<YOUR-LPSNG-BASE>/oauth2/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -u "<CLIENT_ID>:<CLIENT_SECRET>" \
  -d "grant_type=client_credentials"

A successful response includes a bearer token:

{
  "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "token_type": "Bearer",
  "expires_in": 3600
}

Use that access_token value in the Authorization header for the binding request. Check the OAuth2 guide if your tenant uses a different token request shape.

Step 2: Identify the Item and the Tag

You need two identifiers before you can bind anything:

• Item identifier: Usually the SKU, EAN, or internal material number that already exists in your LPSNG data source.
• Tag identifier: The unique ESL tag ID. This is often printed on the tag itself or captured by scanning the tag with an MDE unit.

For example, an item might be identified as EAN-4001234567890, and a tag might be identified as CATIC-001234. Keep both values handy for the JSON payload.

Step 3: Construct the Binding Request

A binding request is a JSON object sent to the binding endpoint. The required fields are the item identifier and the tag identifier. Depending on your label layout and ESL configuration, you can also send optional fields such as price or a labelData object.

{
  "itemId": "EAN-4001234567890",
  "tagId": "CATIC-001234",
  "price": "19.90",
  "labelData": {
    "name": "Organic Oat Milk 1L",
    "unit": "L"
  }
}

Not all deployments use price and labelData. If your labels are driven entirely by the item master data in LPSNG, you can send only itemId and tagId. Check your label layout to see which additional fields the tag should display.

Step 4: Send a POST Request to the Binding Endpoint

For this tutorial we use /api/esl/bind as the binding endpoint. Your LPSNG installation may expose the same path or a tenant-specific path, so confirm the exact endpoint in the ESL Binding API documentation for your environment.

Save the payload to a file so the curl command stays readable:

{
  "itemId": "EAN-4001234567890",
  "tagId": "CATIC-001234",
  "price": "19.90",
  "labelData": {
    "name": "Organic Oat Milk 1L",
    "unit": "L"
  }
}

Then send the request:

curl -s -X POST "https://<YOUR-LPSNG-BASE>/api/esl/bind" \
  -H "Authorization: Bearer <ACCESS_TOKEN>" \
  -H "Content-Type: application/json" \
  --data @binding-payload.json

LPSNG receives the request, resolves the item data in your data source, and instructs the ESL base station to update the tag.

Step 5: Handle the Response

A successful binding normally returns a 200 OK response with a status object:

{
  "status": "bound",
  "tagId": "CATIC-001234",
  "itemId": "EAN-4001234567890",
  "updatedAt": "2026-09-21T10:15:00Z"
}

Common error responses include:

• 400 for invalid data, such as a malformed JSON body or a missing required field.
• 401 for authentication failure, for example an expired or missing access token.

Inspect the response body for an error message that explains which field failed. If the API returns another 4xx status, check whether the tag or item is unknown or whether the tag is already bound elsewhere.

Step 6: Verify the Binding by Querying Tag Status

If your deployment exposes a tag status endpoint, you can query the current binding. The exact endpoint may vary; the following is an example shape:

curl -s "https://<YOUR-LPSNG-BASE>/api/esl/status/CATIC-001234" \
  -H "Authorization: Bearer <ACCESS_TOKEN>"

A response similar to this confirms that the tag is bound to the expected item:

{
  "tagId": "CATIC-001234",
  "boundItemId": "EAN-4001234567890",
  "lastSeen": "2026-09-21T10:15:00Z"
}

If your tenant does not expose a status endpoint, use the ESL management dashboard in LPSNG to see the tag status.

Step 7: Optional — Unbind or Rebind a Tag

When an item moves to a new location or a tag is reused, you need to unbind or rebind it. The exact method depends on your LPSNG binding endpoint.

A common unbind request uses DELETE:

curl -s -X DELETE "https://<YOUR-LPSNG-BASE>/api/esl/bind/CATIC-001234" \
  -H "Authorization: Bearer <ACCESS_TOKEN>"

To rebind the same tag to a different item, send a PUT request:

curl -s -X PUT "https://<YOUR-LPSNG-BASE>/api/esl/bind/CATIC-001234" \
  -H "Authorization: Bearer <ACCESS_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"itemId":"EAN-4001234567891"}'

Check the ESL Binding API documentation for the exact unbind and rebind behavior in your installation.

Verifying the Binding

After the API call returns success, confirm the binding in more than one way:

• Check the ESL display physically — the tag should now show the item’s price and name. If the display is still blank or showing old data, wait a few seconds and check again.
• Query the tag status through the ESL interface if your deployment provides one. The status response should show the expected boundItemId.
• Open the ESL management dashboard in LPSNG and find the tag. Its status should change from unbound or previous item to the new item.
• Test with a different item and rebind the same tag. If the display updates correctly, your integration is working end to end.

Troubleshooting Common Issues

Authentication errors

Double-check your OAuth2 client ID and secret. Access tokens expire, so renew the token if you receive a 401 response after a period of time.

Tag not found

Make sure the tag ID is exactly correct, including any prefixes or leading zeros. Also confirm the tag is powered on and within range of the ESL base station. A tag that has not reported recently may not be available for binding.

Item not found

Verify that the item identifier exists in your LPSNG data source. The binding API resolves against the same data that your labels use, so a typo in the EAN or SKU will prevent binding.

Binding conflict

The tag may already be bound to another item. Unbind the tag first, then send a fresh binding request. Some installations reject a direct rebind without an explicit unbind step.

Network issues

If the request times out, check connectivity between your client, the LPSNG web service, and the ESL base station. The base station must be reachable from LPSNG, not directly from your client.

FAQ

What is the ESL Binding API?

The ESL Binding API is a web service provided by the Next Generation Label Printing System (LPSNG) that allows external systems such as mobile data entry units to bind electronic shelf label tags to specific items. It uses a simple JSON request over HTTPS.

Can I bind multiple tags to one item?

Typically, one tag is bound to one item. However, depending on your ESL hardware and LPSNG configuration, you may be able to bind multiple tags to the same item for redundancy or different display locations. Check your hardware documentation.

How do I unbind a tag?

To unbind a tag, you can send a request to the binding endpoint with an empty or null item identifier, or use a dedicated unbind method if available. Refer to the API documentation for the exact endpoint and payload.

Is the binding API available in all LPSNG editions?

Yes, the ESL Binding API is part of the core LPSNG functionality and is available in all editions, including the cloud solution and embedded edition. However, you need compatible ESL hardware to use it.

Conclusion

The binding workflow is a small loop: authenticate, collect the item and tag IDs, send the binding request, and verify the display. Once that loop works, you can call it from an MDE unit, a fulfillment process, or any other external system that needs to assign ESL tags to items.

The ESL Binding API is only one part of the broader LPSNG ESL solution. LPSNG also provides the vendor-neutral ESL Interface for updating displays, the OAuth2 guide for authentication, and the LPSNG Player for command-line ESL output workflows.

If you are integrating ESL hardware for the first time, start with the ESL Binding API documentation and test against a spare tag before moving to production.

Related posts

• What Is a Label Printing API? A Beginner’s Guide
• How to Create Barcode Labels in Your Browser: Step-by-Step
• Automate Customer-Specific Labels in Your Fulfillment Process