Plug your store, site, or stack into your fleet.

1. Mint a key — fleet owners go to Fleet → Developer console, name the key, pick scopes, copy the pk_live_… secret (shown once — only its SHA-256 digest is stored).
2. Verify it — GET /api/v1/me returns your scopes, plan, and rate limits.
3. Ship a delivery — POST /api/v1/delivery-requests lands a pending request in the fleet's Dispatch queue.

curl https://api.primetransit.com/api/v1/me \
  -H "X-Api-Key: pk_live_…"

curl -X POST https://api.primetransit.com/api/v1/delivery-requests \
  -H "X-Api-Key: pk_live_…" \
  -H "Content-Type: application/json" \
  -d '{
    "customer": { "name": "Ava Chen", "email": "ava@example.com", "phone": "+15551234567" },
    "pickup":  { "address": "1200 S Main St, Burbank, CA 91506" },
    "dropoff": { "address": "88 Oak Ave, Glendale, CA 91205" },
    "vehicleClass": "van",
    "scheduledAt": "2026-10-16T15:00:00-07:00",
    "notes": "Order #1042 — leave at door"
  }'

{
  "success": true,
  "requestId": "7f3c…",
  "trackingCode": "PT-8KQ2-MP4R",
  "jobNumber": "PRIME-000482",
  "trackUrl": "https://primetransit.com/track?id=…"
}

Send trackUrl to your customer — it's a live tracking page that updates as the fleet accepts, assigns, and completes the delivery.

Every v1 request carries an API key in the X-Api-Key header. Keys are fleet-scoped — a key can only read and write its own fleet's data.

Scopes gate every endpoint. A call without the required scope returns 403 listing the missing scopes.

Keys are managed at /fleet/developers or via /api/api-keys (JWT-authenticated). Disable a key instantly with PATCH { "active": false }, or revoke permanently.

Limits are per API key and follow your fleet's subscription. Every response carries headers so you can back off before hitting the wall.

{
  "success": false,
  "error": "Rate limit exceeded",
  "limit": 30,
  "window": "1 minute",
  "retryAfter": 42
}

Base URL: https://api.primetransit.com · Lists accept ?limit=1..200&offset=0 and return { data: [...], count: N }.

{
  "customer": { "name": "Ava Chen", "email": "ava@example.com", "phone": "+15551234567" },
  "pickup":  { "address": "1200 S Main St, Burbank, CA", "lat": 34.18, "lng": -118.33 },
  "dropoff": { "address": "88 Oak Ave, Glendale, CA" },
  "serviceType": "delivery",
  "vehicleClass": "van",
  "scheduledAt": "2026-10-16T15:00:00-07:00",
  "packageDetails": { "size": "boxes", "pieces": 3, "weightLbs": 42 },
  "notes": "Order #1042"
}

What happens after your POST — and which webhook fires at each step.

Poll GET /api/v1/tracking/:code or subscribe to job.status_changed — webhooks are the right tool for real-time sync.

Register an HTTPS URL and PRIME POSTs signed events. Deliveries retry up to 3 times with exponential backoff (~1s, ~5s + jitter). Every attempt is logged — inspect via GET /api/v1/webhooks/:id/deliveries.

const crypto = require('crypto');

function verifyPrimeSignature(rawBody, header, secret) {
  const parts = Object.fromEntries(
    header.split(',').map(kv => kv.split('='))
  );
  const expected = crypto
    .createHmac('sha256', secret)
    .update(`${parts.t}.${rawBody}`)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(expected), Buffer.from(parts.v1 || '')
  );
}

curl -X POST https://api.primetransit.com/api/v1/webhooks \
  -H "X-Api-Key: pk_live_…" \
  -H "Content-Type: application/json" \
  -d '{ "url": "https://your-app.com/hooks/prime", "events": ["delivery_request.created", "job.completed"] }'

Full event catalog: job.*, driver.*, vehicle.*, lead.*, ticket.*, delivery_request.*, payment.*, invoice.*, subscription.*, shift.* — or subscribe to * for everything.

No native app install needed: two webhook hops and every paid order lands in Dispatch.

1. Shopify → your middleware — in Shopify Admin → Settings → Notifications → Webhooks, subscribe orders/paid to your endpoint (or use Shopify Flow → "Send HTTP request" on the Advanced plan).
2. Middleware → Prime Fabric — map the order to a delivery request and POST it with your key.
3. Status back to Shopify — subscribe your middleware to job.status_changed and update the order's fulfillment status.

app.post('/shopify/order-paid', express.raw({ type: 'application/json' }), async (req, res) => {
  const order = JSON.parse(req.body);
  const a = order.shipping_address;

  const resp = await fetch('https://api.primetransit.com/api/v1/delivery-requests', {
    method: 'POST',
    headers: {
      'X-Api-Key': process.env.PRIME_API_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      customer: {
        name: `${a.first_name} ${a.last_name}`,
        email: order.email,
        phone: a.phone || order.phone,
      },
      pickup:  { address: process.env.WAREHOUSE_ADDRESS },
      dropoff: { address: `${a.address1}, ${a.city}, ${a.province_code} ${a.zip}` },
      notes: `Shopify order ${order.name}`,
      packageDetails: {
        weightLbs: order.total_weight ? order.total_weight / 453.6 : undefined,
        pieces: order.line_items.reduce((n, li) => n + li.quantity, 0),
      },
    }),
  });

  const created = await resp.json();
  // created.trackUrl → send to the customer or attach to the order
  res.json({ ok: true, requestId: created.requestId });
});

Zero-code alternative: Zapier/Make — trigger on "New Paid Order (Shopify)", action "Webhooks → POST" to /api/v1/delivery-requests with the X-Api-Key header. For simple "book a delivery" buttons on product pages, embed the hosted form (see WordPress section — the iframe works anywhere).

The prime-booking plugin embeds your fleet's hosted booking form. Requests land in Dispatch exactly like API-created ones.

1. Get your fleet's booking slug from Fleet → Integrations (the "Website booking widget" panel also generates the embed snippet).
2. Upload prime-booking.zip via Plugins → Add New → Upload, activate.
3. Set the slug under Settings → PRIME Booking.

[prime_book]          <!-- inline booking form -->
[prime_book_button]   <!-- button that opens the form in a modal -->
[prime_book_button label="Get a delivery quote"]

Deeper integration (order handoff from WooCommerce, custom forms) → use the REST API directly: POST /api/v1/delivery-requests from your theme/plugin PHP with wp_remote_post, same body as the Shopify example.

Customers text your fleet's phone number; the platform parses pickup/dropoff with AI, creates a pending delivery request, and replies with a tracking link. No app, no form.

Customer:  "Need a pickup at 1200 S Main St Burbank to 88 Oak Ave Glendale by 3pm"

Fleet #:   "PRIME FLEET received your request!
            Pickup: 1200 S Main St Burbank to 88 Oak Ave Glendale
            Ref: PRIME-000483
            Track: https://primetransit.com/track?id=…
            Reply STOP to unsubscribe."

Telnyx inbound webhook → POST /api/webhooks/telnyx/inbound → AI parse → delivery_request (source=sms) → signed reply. STOP/START/HELP keywords are handled for 10DLC compliance automatically.

Error body: { "statusCode", "message", "error" }. The API is versioned by URL (/api/v1) — additive changes (new fields, endpoints, events) ship without a version bump; breaking changes get a new version path.

The API grows from real integrations — tell us what you're building and what's missing.