One canonical order
A single, versioned JSON model for every platform. No more per-platform parsing in your POS.
Integrate RapidHub once and receive orders from Wolt, Uber Eats, Delivery Hero and Just Eat Takeaway in one canonical format, in real time. Status updates, menus and opening hours flow back through the same API.
Every delivery platform has its own API, authentication, webhooks, menu format and rate limits, and each one changes on its own schedule. RapidHub absorbs that work so your POS speaks a single, stable API.
Every order arrives as the same JSON: items, options, notes, customer, delivery details, discounts, fees and taxes, with money in minor units.
Accept, reject, ready, picked up and delivered: one call, and RapidHub translates it into each platform's own flow, deadlines and reason codes.
Push your menu once. RapidHub converts it per platform, queues stock changes and respects every platform's rate limits.
Schematic. Available data flows depend on each platform.
Start in the sandbox with test orders. When a restaurant goes live, you only add its platform connection; your POS code stays the same.
Each restaurant gets its own key. Your POS stores it and uses it for every call.
Link the restaurant's Wolt, Uber Eats, Delivery Hero or Just Eat Takeaway store in the dashboard. Credentials are stored encrypted.
Open one WebSocket to /hubs/orders. Every new, updated or canceled order arrives as an OrderEvent.
Accept, mark ready or reject with POST /pos/orders/{id}/state. RapidHub updates the platform for you.
import * as signalR from "@microsoft/signalr";
const HUB = "https://hub.rapidpaygroup.com";
const hub = new signalR.HubConnectionBuilder()
.withUrl(`${HUB}/hubs/orders?access_token=${key}`, {
transport: signalR.HttpTransportType.WebSockets,
skipNegotiation: true,
})
.withAutomaticReconnect()
.build();
// Wolt, Uber Eats, Delivery Hero, Just Eat: one event, one format
hub.on("OrderEvent", async (e) => {
const order = JSON.parse(e.order); // canonical order 2.0
await printKitchenTicket(order);
await fetch(`${HUB}/pos/orders/${e.orderId}/state`, {
method: "POST",
headers: {
"X-Restaurant-Key": key,
"Content-Type": "application/json",
},
body: JSON.stringify({ state: "Accepted", prepTimeMinutes: 20 }),
});
});
await hub.start();
# Catch up on open orders
curl https://hub.rapidpaygroup.com/pos/orders/active \
-H "X-Restaurant-Key: $RAPIDHUB_KEY"
# Accept an order: RapidHub informs the platform
curl -X POST https://hub.rapidpaygroup.com/pos/orders/$ORDER_ID/state \
-H "X-Restaurant-Key: $RAPIDHUB_KEY" \
-H "Content-Type: application/json" \
-d '{"state":"Accepted","prepTimeMinutes":20}'
# Push your menu to every connected platform
curl -X POST https://hub.rapidpaygroup.com/pos/catalog/push \
-H "X-Restaurant-Key: $RAPIDHUB_KEY" \
-H "Content-Type: application/json" \
-d @menu.json
Everything a POS needs to take delivery orders reliably, without maintaining a connector per platform.
A single, versioned JSON model for every platform. No more per-platform parsing in your POS.
Orders reach the till over WebSocket the moment the platform sends them, with a REST catch-up after any reconnect.
Webhooks are stored before they are acknowledged. Retries, reconciliation and idempotency keep every order exactly once.
Accept, reject with reason, preparation time, ready, picked up, delivered: mapped to each platform's own state machine and deadlines.
One menu push for all platforms, including prices, options, allergens and deposits. Sold-out items and opening hours follow.
Platform credentials encrypted with AES-256-GCM, signed webhooks verified, rotatable restaurant keys and two-factor login.
Chains and groups: every branch has its own key and connections, and each order is routed to exactly one restaurant.
A built-in mock platform sends test orders and validates menus, so you can build before any platform approves a test store.
Restaurants, connections, live orders, delivery log and usage in one dashboard, in English, German and Spanish.
Implement one API instead of a connector per platform, and offer delivery integrations to all your customers.
POS → RapidHub → platforms Docs → For restaurants and chainsStop typing tablet orders into the till. Connect each branch's delivery accounts and manage them in one place.
Branches → RapidHub → POS Sign up → For ordering platformsIntegrate with RapidHub once and your orders reach every POS connected to it. Let's talk about a partnership.
Platform → RapidHub → POS Contact →Decide how much of the setup lives in your product and how much in RapidHub.
Create restaurants and connections by API and keep the whole experience inside your POS.
Use the RapidHub dashboard for onboarding, platform connections and order monitoring.
Orders and status through the API, setup and support through the dashboard.
Guides, a full order model, a "Try it" console and examples in cURL, C#, Kotlin and JavaScript.
Quickstart, authentication, real-time connection and the order lifecycle.
Every endpoint with schemas and a live "Try it" console.
Generate a client in your language from the OpenAPI 3 document.
Collection and environment, including a complete sandbox flow.
Create an account, add a restaurant and send a test order from the sandbox. No platform contract needed to start.