Custom Order Tracking API & Webhook Integration

Build Custom Integrations with the REST API and Webhooks

TrackMy.Shop connects natively to Shopify, WooCommerce, and Invoice Ninja. But if your business uses a custom ordering system, an ERP, a homegrown POS, or any platform that does not have a built-in integration, the REST API and outgoing webhooks let you build exactly the connection you need.

The API gives you full programmatic control over your orders. The webhooks push real-time notifications to your systems when things happen. Together, they let you wire TrackMy.Shop into virtually any tech stack.

Overview of What Is Possible

With the API and webhooks, you can:

• Create orders from any external system -- a POS, a CRM, a custom website, or even a Google Sheet
• Update order statuses programmatically as orders move through external processes
• Read order data to display production status in your own dashboards or apps
• Receive real-time event notifications via webhooks when orders are created, updated, moved between stages, or completed
• Batch import orders from CSV files, databases, or other systems
• Sync statuses bidirectionally between TrackMy.Shop and your other tools
• Trigger automations in Zapier, Make, n8n, or any workflow tool that accepts webhooks

Getting Started with API Keys

Authentication uses API keys, which you generate from your TrackMy.Shop dashboard. There are no complex OAuth flows for server-to-server communication -- just a key in your request header.

To create an API key:

1. Go to your workspace Settings > API
2. Click Generate new key
3. Give the key a descriptive name (e.g., "POS Integration" or "Zapier Connection")
4. Copy and store the key securely -- it is shown only once

Include the key in your requests as a Bearer token in the Authorization header:

Authorization: Bearer your_api_key_here

Each API key is scoped to your workspace. You can generate multiple keys for different integrations and revoke them individually if needed. See our API overview help article for full details.

Creating Orders via API

The most common API use case is pushing orders into TrackMy.Shop from an external system. The endpoint accepts a JSON payload with the order details:

POST /api/v1/orders

{
  "orderNumber": "POS-1042",
  "customerName": "Riley Chen",
  "customerEmail": "riley@example.com",
  "shippingAddress": {
    "line1": "742 Craft Lane",
    "city": "Portland",
    "state": "OR",
    "zip": "97201"
  },
  "items": [
    {
      "name": "Custom Embroidered Cap",
      "quantity": 3,
      "sku": "CAP-EMB-BLK"
    },
    {
      "name": "Screen Print Tee (XL)",
      "quantity": 12,
      "sku": "TEE-SP-XL-WHT"
    }
  ],
  "notes": "Rush order -- need by Friday"
}

The order appears on your Kanban board in the first workflow stage immediately. Your team sees it alongside orders from Shopify, WooCommerce, or any other source. Every order gets a barcode and a customer tracking page, regardless of how it was created.

The API also supports updating existing orders, adding notes, changing the assigned stage, and marking orders as complete. Full endpoint documentation is available in the interactive API docs at /api/docs within your TrackMy.Shop workspace.

Listening for Events with Webhooks

Outgoing webhooks notify your systems in real time when something happens in TrackMy.Shop. You configure a webhook by providing a URL and selecting which events should trigger it.

Available webhook events include:

• order.created -- a new order was added (from any source)
• order.updated -- order details were modified
• order.stage.changed -- an order moved to a different workflow stage

Each webhook sends a POST request to your URL with a JSON payload containing the full order data and the event type. The payload format is designed to be straightforward and Zapier-compatible, so you can point a webhook directly at a Zapier catch hook without writing any transformation code.

Example webhook payload for a stage change:

{
  "event": "order.stage.changed",
  "timestamp": "2026-02-07T14:30:00Z",
  "order": {
    "id": "ord_abc123",
    "orderNumber": "POS-1042",
    "customerName": "Riley Chen",
    "stage": "Screen Printing",
    "previousStage": "Prep",
    "items": [...],
    "createdAt": "2026-02-05T09:15:00Z"
  }
}

To set up a webhook, go to Settings > Webhooks in your workspace, enter the destination URL, select the events you want, and save. TrackMy.Shop will start sending events immediately.

Building a Zapier Integration

If you use Zapier for workflow automation, connecting TrackMy.Shop is straightforward. You have two options:

Trigger (TrackMy.Shop to Zapier): Create a webhook in TrackMy.Shop that points to a Zapier "Webhooks by Zapier" catch hook trigger. When an order event fires, Zapier receives the data and can route it to any of its thousands of supported apps. For example, you could send a Slack message when an order moves to "Ready to Ship," create a row in a Google Sheet for every completed order, or trigger a follow-up email in Mailchimp.

Action (Zapier to TrackMy.Shop): Use Zapier's "Webhooks by Zapier" action to send a POST request to the TrackMy.Shop API. This lets any Zapier trigger -- a new row in Airtable, a form submission in Typeform, a new deal in a CRM -- create an order in TrackMy.Shop automatically.

The same approach works with Make (formerly Integromat), n8n, and any other automation platform that supports webhooks and HTTP requests.

Real-World Example: Custom POS to Production Floor

Jake runs a custom screen printing shop with a retail counter. Customers walk in, choose a design and a shirt, and place their order at the register. His POS system is a simple custom app his nephew built with a tablet and a receipt printer.

Before TrackMy.Shop, the POS printed a receipt that went into a physical tray. The printing crew would grab receipts and try to work through them in order. Rush orders got sticky notes. It was chaotic during busy weeks.

Now, the POS sends a POST request to the TrackMy.Shop API every time a sale is completed. The order -- customer name, items, sizes, design choice -- appears on the Kanban board instantly. The printing crew sees new orders in the "New Orders" column on a wall-mounted monitor. They drag an order to "Prep" when they start pulling shirts and setting up screens. A barcode scan moves it to "Printing," then "Drying," then "Quality Check," then "Ready for Pickup."

Jake configured a webhook to fire when an order reaches "Ready for Pickup." That webhook hits Zapier, which sends the customer an SMS saying their order is done. The whole flow -- from POS to production to customer notification -- runs without manual data entry.

Advanced Patterns

Batch imports: The API supports creating multiple orders in a single request. This is useful for migrating existing orders from another system, importing daily order files from a wholesale channel, or syncing large backlogs. Batch operations are processed efficiently and all orders appear on the board with full tracking capabilities.

Bidirectional status sync: Combine API writes and webhooks to keep two systems in sync. Push orders to TrackMy.Shop via the API, then use webhooks to update the source system when the order progresses through stages. This is common for businesses connecting ERP or warehouse management systems.

Multi-source aggregation: If your orders come from several places -- a website, a POS, phone orders, wholesale accounts -- route them all to TrackMy.Shop via the API. Every order ends up on the same board with the same workflow stages, giving you a unified view of your production pipeline regardless of where the order originated.

Rate Limits and Best Practices

The API enforces rate limits to ensure reliable service for all users. Standard limits are generous enough for typical integration patterns. If you are building a high-volume integration, keep these practices in mind:

• Use batch endpoints for bulk operations instead of sending hundreds of individual requests
• Implement exponential backoff on rate limit responses (HTTP 429)
• Cache order data locally rather than re-fetching it on every page load
• Subscribe to webhooks for real-time updates instead of polling the API
• Store your API keys securely -- never expose them in client-side code or public repositories

The interactive API documentation at /api/docs includes example requests and responses for every endpoint, making it easy to test and build your integration. For detailed authentication instructions and endpoint references, see our API overview help article.

Getting Started

The API and webhooks are available on all TrackMy.Shop plans, including the free tier (30 orders per month). Paid plans start at $19.99 per month for higher volumes. Generate your first API key, send a test order, and see it appear on your Kanban board in seconds. From there, you can build whatever integration your business needs.