developer.jek.app

JEK · Developer

Public API reference
Consumer, driver, merchant and partner endpoints served at api.jek.app. Download the reference as OpenAPI for your integration.
Base URL
https://api.jek.app
Auth
Bearer token in Authorization header
Environment isolation
Send X-JEK-Env with environment-scoped requests. Use staging for testing. Before reading or caching consumer responses, verify the matching X-JEK-Env and X-JEK-Isolation: 1 response headers.
Status
Audience
Consumer Auth
GET/api/v1/auth/phone-countryJEKStable
https://api.jek.app
Suggest a registration phone country from the visitor IP
Unauthenticated, read-only country hint from Cloudflare CF-IPCountry. Requires explicit X-JEK-Env. Returns {code:200,message:'OK',data:{country:ISO-alpha2|null}} with environment/isolation proof and private, no-store. Unknown/Tor countries return null; no IP or coordinates are returned or stored. A suggestion only, never identity or an access rule.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
POST/api/v1/auth/signin/checkJEKStable
https://api.jek.app
Check whether a phone has completed account setup; unfinished accounts use OTP signup
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • phone (body, string, required)
POST/api/v1/auth/registerJEKStable
https://api.jek.app
Send Supabase signup OTP
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • phone (body, string, required)
  • deviceId (body, string)
POST/api/v1/auth/loginJEKStable
https://api.jek.app
Sign in with Supabase phone and password
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • phone (body, string, required)
  • password (body, string, required)
POST/api/v1/auth/forget-passwordJEKStable
https://api.jek.app
Send password recovery SMS through Supabase
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • phone (body, string, required)
  • deviceId (body, string)
POST/api/v1/auth/forgot-passwordJEKStable
https://api.jek.app
Alias for forget-password
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • phone (body, string, required)
  • deviceId (body, string)
POST/api/v1/auth/otp/sendJEKStable
https://api.jek.app
Send or resend a Supabase SMS OTP
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • phone (body, string, required)
  • action (body, string, required)
  • deviceId (body, string)
POST/api/v1/auth/otp/verifyJEKStable
https://api.jek.app
Verify SMS; signin returns session, signup/pwdreset return completion token
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • phone (body, string, required)
  • action (body, string, required)
  • token (body, string, required)
  • deviceId (body, string)
  • aut_code (body, string, required)
POST/api/v1/auth/verificationJEKStable
https://api.jek.app
Alias for otp/verify
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • phone (body, string, required)
  • action (body, string, required)
  • token (body, string, required)
  • deviceId (body, string)
  • aut_code (body, string, required)
POST/api/v1/auth/signup/completedJEKStable
https://api.jek.app
Set name after phone verification; return Supabase session
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • token (body, string, required)
  • deviceId (body, string)
  • first_name (body, string, required)
  • last_name (body, string, required)
  • password (body, string)
POST/api/v1/auth/phone/change/startJEKStable
https://api.jek.app
Send a code to the number currently on the account
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
  • deviceId (body, string)
POST/api/v1/auth/phone/change/verifyJEKStable
https://api.jek.app
Verify the current number's code; returns the proof the next step needs
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
  • token (body, string, required)
  • aut_code (body, string, required)
  • deviceId (body, string)
POST/api/v1/auth/phone/change/sendJEKStable
https://api.jek.app
Send a code to the new number; repeatable to resend or correct it
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
  • token (body, string, required)
  • new_phone (body, string, required)
  • deviceId (body, string)
POST/api/v1/auth/phone/change/confirmJEKStable
https://api.jek.app
Verify the new number's code; applies the change and returns the session
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
  • token (body, string, required)
  • aut_code (body, string, required)
  • deviceId (body, string)
POST/api/v1/auth/account/delete/startJEKStable
https://api.jek.app
Start deleting the account: send a code to the phone on it
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
  • deviceId (body, string)
POST/api/v1/auth/account/delete/confirmJEKStable
https://api.jek.app
Verify that code; schedules deletion in 30 days and signs out every device (signing in cancels it)
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
  • token (body, string, required)
  • aut_code (body, string, required)
  • deviceId (body, string)
  • reason (body, string)
POST/api/v1/auth/password/signinJEKStable
https://api.jek.app
Alias for login
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • phone (body, string, required)
  • password (body, string, required)
POST/api/v1/auth/profile/completeJEKStable
https://api.jek.app
Complete a phone-verified account profile and set its password
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
  • first_name (body, string, required)
  • last_name (body, string, required)
  • password (body, string, required)
POST/api/v1/auth/password/resetJEKStable
https://api.jek.app
Spend recovery proof and update Supabase password
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • token (body, string, required)
  • deviceId (body, string)
  • password (body, string, required)
POST/api/v1/auth/session/refreshJEKStable
https://api.jek.app
Rotate the Supabase session
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
no auth
Parameters
  • X-User-Scope (header, string)
  • refresh_token (body, string, required)
POST/api/v1/auth/session/logoutJEKStable
https://api.jek.app
Revoke the current Supabase refresh session
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
GET/api/v1/auth/profileJEKStable
https://api.jek.app
Read authenticated consumer profile
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
PATCH/api/v1/auth/profileJEKStable
https://api.jek.app
Update the consumer's name and/or saved language
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
  • first_name (body, string)
  • last_name (body, string)
  • preferred_lang (body, string)
GET/api/v1/auth/scopesJEKStable
https://api.jek.app
Read the consumer's product memberships
Native Supabase Auth. Responses use {code,message,data}. Success code=200; failures use HTTP 400/401/403/409/429/503. No legacy/Wonder consumer authentication.
Auth
user_bearer
Parameters
  • X-User-Scope (header, string)
Platform
GET/api/v1/config/bootstrapJEKStable
https://api.jek.app
Client bootstrap configuration
Public runtime config for web and native clients: API base, map keys scope, feature flags and channel branding.
Auth
no auth
POST/api/wonder/qr-startJEKStable
https://api.jek.app
Start a Wonder QR sign-in session
Returns a session id and QR payload to display. Poll /api/wonder/qr-poll until it resolves.
Auth
no auth
GET/api/wonder/qr-pollJEKStable
https://api.jek.app
Poll a Wonder QR sign-in session
Auth
no auth
Parameters
  • id (query, string, required)
  • role (query, string)
POST/api/agent/voice-extractJEKStable
https://api.jek.app
Extract a ride request from a voice transcript
AI helper used by the voice assistant to turn speech into structured pickup / dropoff / options. Multipart `audio` (≤8 MB), optional `origin` / `destination`. Signed-in passengers only (401 otherwise); at most 10 a minute per passenger (429); logged to AI usage.
Auth
user_bearer
GET/api/public/v1/healthJEKStable
https://api.jek.app
Health probe
Auth
no auth
GET/api/public/v1/maps-configJEKStable
https://api.jek.app
Public Google Maps browser key + tracking ID
Auth
no auth
GET/api/public/v1/openapiJEKStable
https://api.jek.app
OpenAPI 3.1 spec (JSON)
Auth
no auth
Geo
POST/api/v1/geo/suggestJEKStable
https://api.jek.app
Smart place suggestions for the Pickup and Dropoff fields
Server-owned STG Ride location primitive. With an empty `input` it recommends places before the rider types — saved Home/Work/custom places, repeated and recent trips, and real nearby points of interest, ranked by distance, recency, frequency and weekday/time-of-day (docs/25 §3). With a non-empty `input` it merges provider autocomplete with the rider's own places, keeping exact saved matches on top. Every row carries a stable `reason` code (current_location, nearby_pickup, nearby_poi, saved_home, saved_work, saved_place, recent_pickup, recent_destination, frequent_pickup, frequent_destination, repeated_route, commute_pattern, autocomplete), a `source`, `distance_m` and a QA `score`; `meta.ranking_version` names the ranking. The frontend still shows the live GPS row itself, removes what is already selected and trims to 10. The rider comes from the bearer; no user id is read from the body.
Auth
user_bearer
Parameters
  • type (body, "initial" | "destination")
  • input (body, string)
  • current_location (body, object)
  • pickup (body, object)
  • selected_place_ids (body, string[])
  • limit (body, integer)
  • timezone (body, string)
  • session_token (body, string)
  • is_home_page (body, boolean)
POST/api/v1/geo/placeJEKStable
https://api.jek.app
Resolve one place
Server-owned STG Ride location primitive. The mobile client never calls the map or Wonder provider directly.
Auth
user_bearer
POST/api/v1/geo/reverseJEKStable
https://api.jek.app
Reverse geocode coordinates
Server-owned STG Ride location primitive. The mobile client never calls the map or Wonder provider directly.
Auth
user_bearer
POST/api/v1/geo/access-pointsJEKStable
https://api.jek.app
List pickup access points
Server-owned STG Ride location primitive. The mobile client never calls the map or Wonder provider directly.
Auth
user_bearer
POST/api/v1/geo/routeJEKStable
https://api.jek.app
Route polyline, distance and ETA between two points
Driving route used to render the booking map and feed distance into fare quotes.
Auth
user_bearer
Parameters
  • pickup (body, object, required)
  • dropoff (body, object, required)
Passenger
POST/api/v1/passenger/quotesJEKStable
https://api.jek.app
Quote a trip
Resolves Standard Ride places server-side, returns real Wonder quotes and persists the owned, expiring batch before responding.
Auth
user_bearer
GET/api/v1/passenger/catalogsJEKStable
https://api.jek.app
Get ride cancellation and evaluation catalogs
Authenticated passenger-trip operation used by the STG Standard Ride flow.
Auth
user_bearer
POST/api/v1/passenger/nearbyJEKStable
https://api.jek.app
List nearby taxis
Authenticated passenger-trip operation used by the STG Standard Ride flow.
Auth
user_bearer
POST/api/v1/passenger/serviceabilityJEKStable
https://api.jek.app
Check pickup serviceability
Authenticated passenger-trip operation used by the STG Standard Ride flow.
Auth
user_bearer
GET/api/v1/passenger/trips/{id}/cancel-previewJEKStable
https://api.jek.app
Preview trip cancellation
Authenticated passenger-trip operation used by the STG Standard Ride flow.
Auth
user_bearer
POST/api/v1/passenger/trips/{id}/locationJEKStable
https://api.jek.app
Publish passenger location
Authenticated passenger-trip operation used by the STG Standard Ride flow.
Auth
user_bearer
POST/api/v1/passenger/trips/{id}/vehicle-classesJEKStable
https://api.jek.app
Add trip vehicle classes
Authenticated passenger-trip operation used by the STG Standard Ride flow.
Auth
user_bearer
POST/api/v1/passenger/trips/{id}/location-quoteJEKStable
https://api.jek.app
Quote a trip location change
Authenticated passenger-trip operation used by the STG Standard Ride flow.
Auth
user_bearer
POST/api/v1/passenger/trips/{id}/location-confirmJEKStable
https://api.jek.app
Confirm a trip location change
Authenticated passenger-trip operation used by the STG Standard Ride flow.
Auth
user_bearer
POST/api/v1/passenger/trips/{id}/evaluationJEKStable
https://api.jek.app
Evaluate a completed trip
Authenticated passenger-trip operation used by the STG Standard Ride flow.
Auth
user_bearer
GET/api/v1/passenger/trips/{id}/related-activitiesJEKStable
https://api.jek.app
List related trip activities
Authenticated passenger-trip operation used by the STG Standard Ride flow.
Auth
user_bearer
POST/api/v1/passenger/tripsJEKStable
https://api.jek.app
Create a trip
Accepts batch_id and selected_quote_ids only. Locations and prices are re-read from the caller's unexpired server-owned quote batch.
Auth
user_bearer
GET/api/v1/passenger/tripsJEKStable
https://api.jek.app
List my trips
Auth
user_bearer
GET/api/v1/passenger/trips/{id}JEKStable
https://api.jek.app
Get a trip
Auth
user_bearer
POST/api/v1/passenger/trips/{id}/cancelJEKStable
https://api.jek.app
Cancel a trip
Auth
user_bearer
POST/api/v1/passenger/trips/{id}/payJEKStable
https://api.jek.app
Confirm trip payment and dispatch
Records caller-supplied payment confirmation and then creates the Wonder taxi order. It does not charge a payment method.
Auth
user_bearer
POST/api/v1/payments/chargeJEKStable
https://api.jek.app
Charge a payment method
Auth
user_bearer
GET/api/v1/ride-ordersJEKStable
https://api.jek.app
List ride orders
Auth
user_bearer
POST/api/v1/ride-ordersJEKStable
https://api.jek.app
Create a ride order
Auth
user_bearer
POST/api/v1/ride-orders/{id}/cancelJEKStable
https://api.jek.app
Cancel a ride order
For a Wonder order id, focus=false previews cancellation, focus=true confirms it, and submit_reason_only=true submits post-cancel feedback. Native UUID orders use the migration dispatcher.
Auth
user_bearer
Parameters
  • id (path, string, required)
  • focus (body, boolean)
  • submit_reason_only (body, boolean)
  • cancel_type (body, string | number)
  • cancel_remark (body, string)
POST/api/v1/me/ridesJEKStable
https://api.jek.app
Request a ride (Make a Wish)
Creates a ride request with optional wish text/audio, analysis metadata and tip. Send vehicle_class_ids to accept several classes at once and be matched by whichever driver turns up first: the selection is priced HERE and the passenger is charged the DEAREST of it, so the fare is covered whichever class arrives. The request's own `fare` is not consulted for a selection — a caller who named its own total would also get to decide which class counted as dearest. Send duration_min alongside it, or the reprice drops the per-minute component and lands under the quote you showed. Refuses a pickup whose service area is fulfilled by PARTNER capacity with 422 `PARTNER_FULFILMENT_REQUIRED`, carrying `fulfilment` and `fulfilment_area`: that market is served by a third party through Wonder, and this lane has no payment gateway to buy it with. Call /api/v1/ride/preflight first to learn which fulfilment applies.
Auth
user_bearer
Parameters
  • pickup (body, string, required)
  • dropoff (body, string, required)
  • distance_km (body, number)
  • duration_min (body, number)
  • vehicle_class_ids (body, uuid[])
  • fare (body, number)
  • order_type (body, "ride" | "wish")
  • card_scheme (body, string)
  • quote (body, object)
POST/api/v1/me/street-hail/resolveJEKStable
https://api.jek.app
What a scanned taxi QR is
Body `{qr_content}` — a wonder.taxi sticker or offline meter QR. Answers `{kind: online_meter | offline_meter | virtual_meter, sticker_code, taxi {plate, brand}, meter_order {state, fare, amount_due, currency} | null, settles: jek | wonder, needs_driver_check}`. Never the driver's name or Wonder business. 400 INVALID_CODE, 409 WRONG_ENVIRONMENT / TRIP_FINISHED / NO_DRIVER_ON_METER, 404 TAXI_NOT_FOUND / TRIP_NOT_FOUND.
Auth
user_bearer
Parameters
  • qr_content (body, string, required)
POST/api/v1/me/street-hail/verify-driverJEKStable
https://api.jek.app
Confirm the driver of a virtual meter
Body `{sticker_code, answer}` — the last word of the driver's English name, or the last character of a Chinese one; `letter` (the legacy app's name, used by docs/68) is accepted for `answer`. Checked on the server. Answers `{verified, proof, attempts_left}`; the proof is valid 10 minutes for this passenger and this taxi. 429 after five wrong answers in 10 minutes. Also served at /api/v1/me/street-hail/virtual-meter/verify-driver.
Auth
user_bearer
Parameters
  • sticker_code (body, string, required)
  • answer (body, string, required)
POST/api/v1/me/street-hail/virtual-meter/verify-driverJEKStable
https://api.jek.app
Confirm the driver of a virtual meter (alias)
Alias of POST /api/v1/me/street-hail/verify-driver at the path docs/68 G3 named — same handler, same body (`answer` or `letter`), same answers.
Auth
user_bearer
Parameters
  • sticker_code (body, string, required)
  • letter (body, string, required)
POST/api/v1/me/street-hail/ordersJEKStable
https://api.jek.app
Make a street-hail trip payable
Body `{qr_content, fare?, tips?, proof?}` (fare/tips/proof for a virtual meter; tip ≤ fare). Re-resolves the QR, then creates — or for a trip this passenger already scanned, returns — a ride of `order_type: street_hail` and answers `{ride_id, settles, amount_due, currency, pay}`. Pay with `POST /api/v1/me/rides/{id}/pay` (`mode: settle`), /pay/wallet or /pay/native-wallet; tip afterwards with /tip. 409 TRIP_TAKEN when another passenger is paying for it; 403 DRIVER_NOT_VERIFIED; 502 METER_ORDER_FAILED.
Auth
user_bearer
Parameters
  • qr_content (body, string, required)
  • fare (body, number)
  • tips (body, number)
  • proof (body, string)
POST/api/v1/me/street-hail/orders/{id}/priceJEKStable
https://api.jek.app
What paying a street-hail trip this way costs
Body `{payment_method, card_scheme?}` (`card`, `vault-<id>`, `applepay`, `googlepay` or a wallet id). Answers `{settles, currency, fare, tips, discounts[], amount_due, source, locked}`. A JEK-settled trip gets JEK's payment offer for the method (never on the tip), RECORDED on the ride until a payment order exists (then `locked: true`); the pay routes charge it and 409 PAYMENT_OFFER_METHOD_MISMATCH for another method — call again to switch. A Wonder-settled trip answers Wonder's `price_calculator` (`source: wonder`), or the meter amount when OMS does not answer (`source: meter`), and records nothing. Needs `x-jek-env`. 404 NOT_FOUND; 400 INVALID_PAYMENT_METHOD.
Auth
user_bearer
Parameters
  • id (path, string, required)
  • payment_method (body, string, required)
  • card_scheme (body, string)
GET/api/v1/me/kashJEKStable
https://api.jek.app
Your JEK Kash balance and history
JEK only (403 JEK_ONLY otherwise), explicit x-jek-env, fresh eKYC and recovered-ledger gate (409 JEK_EKYC_REQUIRED / CARD_RECONCILIATION_PENDING / LEGACY_KASH_BALANCE_API_REQUIRED). `{balance, currency:'HKD', balances[{currency, balance}], entries_currency, entries[{id, kind, currency, amount, balance_after, ref_type, ref_id, reason, created_at}], next_cursor}`, newest first; `?limit` 1–200 (50), `?before` = the previous `next_cursor`. Kash is a rebate on JEK Card spend kept PER CURRENCY (a JPY purchase earns Kash JPY) and pays only for spends in its own currency (docs/84). `balances` is the caller's JEK Card program (x-jek-env); `balance`/`entries` stay the HKD Kash every ride and gift uses, and `?currency=JPY` pages that currency instead. Kinds: earn, redeem, gift_out, gift_in, reverse, adjust, migrate (card rebates are `earn`/`reverse` with `ref_type: card_transaction`). Never topped up, never cash.
Auth
user_bearer
Parameters
  • limit (query, number)
  • before (query, string)
  • currency (query, string)
GET/api/v1/me/kash/rulesJEKStable
https://api.jek.app
How JEK Kash is earned and spent
JEK only. `{enabled, classes[{vehicle_type_id, code, name, earn_pct, redeem_allowed}], card_earn_pct, card_earn_pct_by_currency, ride_earn_enabled, ride_redeem_enabled, ride_redeem_cap_pct, gifts_enabled, gift_max_per_message, gift_daily_max, spent_via:['jek_card'], redeemable_on, top_up:false, cash_out:false}`. Kash is earned on JEK Card spend (1% by default, in the spend's currency) and spent through the JEK Card (docs/84); ride rebates, ride-booking redemption (`kash_amount` on `POST /api/v1/me/rides`, OFF by default) and chat gifts are each an operator switch, answered 0 when off. The 85% meter taxi earns 0 and refuses Kash.
Auth
user_bearer
POST/api/v1/me/kash/giftsJEKStable
https://api.jek.app
Send JEK Kash to another JEK user
JEK only (403 JEK_ONLY). `{to_user_id | to_phone, amount (HKD, to the cent), request_id}` → 201 `{entry_id, to_user_id, amount, currency:'HKD', balance, replayed}`. `request_id` is the idempotency key: a retry answers 200 with the first gift (`replayed: true`) and moves nothing. Same rules as a Kash gift in chat: Kash on (403 KASH_OFF), at most `gift_max_per_message` per gift and `gift_daily_max` per Hong Kong day (409 KASH_GIFT_LIMIT), never to yourself (400 KASH_GIFT_SELF), never an overdraft (409 KASH_INSUFFICIENT). The recipient must be a JEK member (404 RECIPIENT_NOT_FOUND); a block either way is 403 CANNOT_GIFT. Both sides see it in `GET /api/v1/me/kash` (`gift_out` / `gift_in`, `ref_type: kash_gift`).
Auth
user_bearer
Parameters
  • to_user_id (body, string)
  • to_phone (body, string)
  • amount (body, number, required)
  • request_id (body, string, required)
POST/api/v1/me/kash/transfersJEKStable
https://api.jek.app
Send Kash to another JEK customer through Wonder
Explicit X-JEK-Env and JEK bearer. {to_user_id, currency, amount (positive decimal string), remark (empty allowed), ref_id (globally unique)}. Server resolves verified parties and calls POST /svc/ts/api/v1/openapi/platform_transfers with type:c2c. 201/200 accepted creation; 202 uncertain/in flight; 409 rejected or reference conflict. The same ref never sends twice.
Auth
user_bearer
GET/api/v1/me/kash/transfersJEKStable
https://api.jek.app
List your C2C transfers or read a stored receipt
Explicit X-JEK-Env and JEK bearer. List with ?type=c2c&sender_user_id=<JEK account id> or receiver_user_id (at least one, one must be the caller). Server maps to Wonder users.id; offset defaults 0, limit defaults 10 (1–100). Returns data.{platform_transfers,offset,limit,has_more}. ?ref_id= alone retains the stored creation receipt; no automatic resend.
Auth
user_bearer
POST/api/v1/me/explore/device-placesJEKStable
https://api.jek.app
Report places the app's on-device Apple Maps search found
JEK only, signed in (docs/82). `{places: [{name, lat, lng, address?, phone?, url?, category?, apple_id?}]}`, 1–25 items (else 400). An item without a 1–200 char name or a Hong Kong point is dropped, not refused; a url that is not http(s) or is over 500 chars, or an `apple_id` not matching `^[A-Za-z0-9._-]{4,120}$`, drops only that field. `apple_id` is MapKit's `MKMapItem.identifier` (iOS 18+), stored as `apple:<id>`. An `apple_id` counts only within 75 m of the stored place it names (otherwise it is dropped). A place a JEK merchant already is (same name within 75 m) is skipped; a stored Apple place (from a search or a device report, owned by no merchant) of the same key and name, or the same name within 75 m, only has its empty website / phone / address / category filled; a merchant's or a Google place is never filled; anything else becomes a new place shown in Explore to everyone and enriched by the cron after every other place. Daily caps per user and for all users together (`explore.sources.device_reports.per_user_daily_cap` / `global_daily_cap`, HKT day, claimed atomically; a place already reported is free). Answers `{data: {accepted, merged, skipped, capped}}`; `accepted: 0` when the admin switch is off; 429 RATE_LIMITED with `Retry-After`.
Auth
user_bearer
Parameters
  • places (body, array, required)
GET/api/v1/me/vouchersJEKStable
https://api.jek.app
Vouchers you hold
JEK only. Claimed merchant vouchers, granted ride coupons and gifts. `?status=held|used|expired|transferred|all` (held). Each `{id, kind: merchant_voucher|ride_coupon, source: claim|grant|gift, status, redeem_code (merchant vouchers, shown at the counter), snapshot, expires_at, used_at}`. Book a ride coupon with `user_voucher_id` on `POST /api/v1/me/rides`; give one in chat with kind='voucher' + `metadata.user_voucher_id`.
Auth
user_bearer
Parameters
  • status (query, string)
POST/api/v1/me/vouchers/claimJEKStable
https://api.jek.app
Claim a merchant voucher
JEK only. `{voucher_id}`. Once per person per voucher: 201 on the claim, 200 with the same instance when already claimed. 404 NOT_FOUND, 409 NOT_AVAILABLE / NOT_STARTED / EXPIRED / SOLD_OUT.
Auth
user_bearer
Parameters
  • voucher_id (body, uuid, required)
GET/api/v1/vouchers/claimableJEKStable
https://api.jek.app
Merchant vouchers that can be claimed now
No sign-in. Published, started, not ended, with quantity left (`remaining`, null = unlimited). `?merchant_id&limit` (≤200).
Auth
no auth
Parameters
  • merchant_id (query, uuid)
  • limit (query, number)
GET/api/v1/me/realtimeJEKStable
https://api.jek.app
How to subscribe to live updates for your own orders
Every ride/trip transition is broadcast on Supabase Realtime as a nudge; re-read the order's `/events` with your cursor when one arrives and keep polling as the fallback. Channels are PRIVATE: call `realtime.setAuth(<your access_token>)` and subscribe to `order:ride:{id}` / `order:trip:{id}` with `config: { private: true }` — only the order's owner is admitted. Returns the project URL and the (public) anon key. 503 when realtime is not configured.
Auth
user_bearer
POST/api/v1/me/rides/{id}/cancelJEKStable
https://api.jek.app
Cancel the caller's own ride or wish order
Marks the caller's own order cancelled and records the reason in the wish metadata. Returns 409 if the order is already completed/cancelled, if a driver has already accepted it (code WISH_ALREADY_CLAIMED), or if the status changed concurrently (code WISH_CHANGED). No refund transaction is written.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • reason (body, string)
GET/api/v1/me/rides/{id}/driver-locationJEKStable
https://api.jek.app
Last known driver location for an order
Rider-facing read of the assigned driver's most recent GPS ping. Poll while the order is accepted / in progress.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/rides/{id}JEKStable
https://api.jek.app
Full detail of one of the caller's rides
The single read the trip screen polls. Scoped by id AND user_id — a ride belonging to someone else answers 404, never 403, so ids cannot be probed. The payload is additive: each feature (driver, cancellation, receipt, events, coupons…) contributes one sibling key, while `fare` stays a bare number for compatibility with older app builds.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/rides/{id}/cancel-previewJEKStable
https://api.jek.app
Preview cancelling this ride
Answers 'what would happen if I cancelled right now' — whether it is allowed and what it would cost — using the same stored policy and evaluator as POST /cancel, so the preview cannot disagree with the charge. Writes nothing.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/rides/{id}/contactJEKStable
https://api.jek.app
Masked contact channels to the assigned driver
How the passenger reaches the driver without either side learning the other's number: a pooled virtual number held for this ride, plus an in-app chat conversation. Offered only while the ride is live; an empty number pool returns 200 with available:false rather than ever exposing the driver's real mobile.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/rides/{id}/contactJEKStable
https://api.jek.app
Open a masked contact channel
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • channel (body, string, required)
DELETE/api/v1/me/rides/{id}/contactJEKStable
https://api.jek.app
Release the ride's masked contact channel
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/rides/{id}/destinationJEKStable
https://api.jek.app
Change where a ride is going
Re-rides the pricing server-side: the request names where to, never a fare. Only the difference between the old and new route's class price moves — boosts, surcharges and tips on top stay on top — and after a driver has claimed the ride the fare can only go up.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • destination (body, object, required)
GET/api/v1/me/rides/{id}/driverJEKStable
https://api.jek.app
Live identity of the assigned driver
Name, plate and rating of the driver working this ride, while they are working it. Gated exactly like /driver-location: caller's own ride only (404 otherwise), and the response goes dark when the trip ends. The permanent record stays on GET /api/v1/me/rides/{id}'s driver block.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/rides/{id}/eventsJEKStable
https://api.jek.app
Incremental event feed for a ride
Cursor-keyed replay of what has changed since the client last asked. The realtime nudge is a Supabase Realtime broadcast on `realtime.topic` (`order:ride:{id}`), published on every lifecycle transition; subscribe to it and call this with the cursor when it fires, or poll at `poll_after_ms` without it. Not SSE/websockets: the deployment is a Cloudflare Worker with no long-lived connections. Events carry `at` (when the row says it happened) beside `observed_at`. Also folds in `driver_location`, `remaining_route` (driver → pickup/drop-off, provider route or a labelled straight-line estimate), `timestamps`, and `actions` — including `can_cancel` from the same cancellation policy the detail and cancel endpoints use, and `can_end_trip`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • cursor (query, string)
POST/api/v1/me/rides/{id}/endJEKStable
https://api.jek.app
End a Wish / ride early (passenger)
Only while `in_trip` — the same predicate the detail publishes as `actions.can_end_trip`. Idempotent: a repeat answers the same success with `already: true`. Writes `status=completed`, `completed_at` and `wish.earlyEnd`; the driver's trip count is bumped exactly as their own completion would (never on a test job) and both parties are notified. No money moves (Module A). 409 `not_in_trip` / `already_finished` / `RIDE_CHANGED`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • note (body, string)
GET/api/v1/me/rides/{id}/shareJEKStable
https://api.jek.app
List the rider's trip-sharing links for a ride
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/rides/{id}/shareJEKStable
https://api.jek.app
Create a secure trip-sharing link
Mints a 256-bit token (returned once, stored hashed) and a public URL (`GET /api/public/v1/trip-shares/{token}`) that serves a minimised live view: phase, short pickup/drop-off labels, driver first name + plate + vehicle, the car's last position while the trip is active, lifecycle times. Never the rider's name/phone, the driver's phone, the fare or addresses beyond the labels. Default TTL 4h (`ttl_ms`, 10 min – 24 h), at most 5 live links per order, revocable. 409 `order_finished` / `too_many_links`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • ttl_ms (body, number)
DELETE/api/v1/me/rides/{id}/shareJEKStable
https://api.jek.app
Revoke trip-sharing links
Every live link on the ride, or one by `?id=`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • id (query, uuid)
GET/api/public/v1/trip-shares/{token}JEKStable
https://api.jek.app
Open a shared trip link (public)
Unauthenticated: the token is the credential. Serves a small HTML page to browsers (auto-refreshes while the trip is active) and the JSON `SharedTripView` to `Accept: application/json` / `?format=json`. Invalid, expired and revoked tokens all answer the same 404. Rate-limited per token.
Auth
no auth
Parameters
  • token (path, string, required)
POST/api/v1/me/rides/{id}/sosJEKStable
https://api.jek.app
Trigger an SOS and notify emergency contacts
Idempotent on `Idempotency-Key` (header or `idempotency_key` body): the same key returns the same event and sends nothing again; without one, presses within a minute collapse. Records the event, mints a share link, and sends one SMS to each VERIFIED emergency contact (optionally narrowed by `contact_ids`) through the configured SMS provider. Every attempt is a `notifications[]` row with a delivery status: `sent`/`failed` with the provider reference, `simulated` on staging without a provider, `skipped:notification_provider_unavailable` elsewhere without one, `skipped:contact_unverified`. 201 on create, 200 on a repeat.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • Idempotency-Key (header, string)
  • lat (body, number)
  • lng (body, number)
  • note (body, string)
  • contact_ids (body, uuid[])
GET/api/v1/me/rides/{id}/sosJEKStable
https://api.jek.app
SOS events on a ride with delivery audit
Auth
user_bearer
Parameters
  • id (path, uuid, required)
DELETE/api/v1/me/rides/{id}/sosJEKStable
https://api.jek.app
Mark an SOS resolved
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • event_id (query, uuid, required)
POST/api/v1/me/rides/{id}/live-activityJEKStable
https://api.jek.app
Register an iOS Live Activity for a ride
Trip-scoped: the ActivityKit push token is bound to this ride only (unique per ride + token; a repeat re-registers). Updates are pushed on every lifecycle transition and an `end` on completion/cancellation/expiry, through APNs when `APNS_*` is configured — `meta.configured: false` means the registration is kept and nothing is faked. 409 `order_finished`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • push_token (body, string, required)
  • activity_id (body, string)
  • platform (body, string)
GET/api/v1/me/rides/{id}/live-activityJEKStable
https://api.jek.app
The caller's Live Activity registrations on a ride
Auth
user_bearer
Parameters
  • id (path, uuid, required)
DELETE/api/v1/me/rides/{id}/live-activityJEKStable
https://api.jek.app
End a ride's Live Activities
All of them, or one by `?push_token=`. Sends ActivityKit `end` when APNs is configured.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • push_token (query, string)
GET/api/v1/passenger/trips/{id}/eventsJEKStable
https://api.jek.app
Resumable event feed for a Standard Ride
A position in the trip's audit log (`jek_passenger_trip_events`): `?cursor=` is the last event the client saw, the answer is every passenger-visible event after it in log order, and the new cursor is the last one returned. `?refresh=1` first polls Wonder DA (the detail's refresh leg) so one call both advances the trip and reads what moved. The realtime nudge is the broadcast topic `order:trip:{id}`. Payloads are never spread — each event carries `{id,type,source,from,to,at,detail}`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • cursor (query, string)
  • refresh (query, string)
POST/api/v1/passenger/trips/{id}/endJEKStable
https://api.jek.app
End a Standard Ride early (passenger)
Only while `in_progress` — the predicate the detail publishes as `capabilities.allow_early_end_trip`. Idempotent (`already: true` on a repeat). Completes the trip on JEK's side (`status`, `completed_at`, `early_end`) and records `trip.ended_early`; Wonder DA has no passenger-side end, so `upstream.ended` is false and `supply_status` keeps following the supplier's order without ever reopening the trip. 409 `trip_not_in_progress` / `trip_changed`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • note (body, string)
POST/api/v1/passenger/trips/{id}/chatJEKStable
https://api.jek.app
Open a chat thread with the driver of a Standard Ride
The Wonder driver must first resolve to a Driver Pro profile (matched by Wonder id or phone; the outcome is remembered on the trip and is what `capabilities.allow_chat` / `allow_chat_reason` report). Opens the same thread model the Wish lane uses, so `/api/v1/me/messaging/*` and the driver's `/api/v1/da/wishes/{id}/messages` serve it. 409 `driver_not_on_jek` / `TRIP_NO_DRIVER` / `TRIP_NOT_LIVE`. `GET` reads the state without opening.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/passenger/trips/{id}/cancel-reasonsJEKStable
https://api.jek.app
The managed cancellation-reason catalog for this trip's stage
The same server-owned catalog the Wish lane uses (`system_configs['ride.cancellation']`), filtered to the trip's stage, with `catalog_version`. `POST …/cancel` accepts `reason_code` (or the legacy numeric `reason_id`); only catalog codes are stored as codes, anything else becomes a note. `GET /api/v1/passenger/catalogs` returns the whole catalog with the same version.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/passenger/trips/{id}/shareJEKStable
https://api.jek.app
Create a trip-sharing link for a Standard Ride
Same contract as `POST /api/v1/me/rides/{id}/share`; `GET` lists, `DELETE` revokes (`?id=` for one).
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • ttl_ms (body, number)
POST/api/v1/passenger/trips/{id}/sosJEKStable
https://api.jek.app
Trigger an SOS on a Standard Ride
Same contract as `POST /api/v1/me/rides/{id}/sos`; `GET` lists events with delivery audit, `DELETE ?event_id=` resolves.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • Idempotency-Key (header, string)
  • lat (body, number)
  • lng (body, number)
  • note (body, string)
  • contact_ids (body, uuid[])
POST/api/v1/passenger/trips/{id}/live-activityJEKStable
https://api.jek.app
Register an iOS Live Activity for a Standard Ride
Same contract as `POST /api/v1/me/rides/{id}/live-activity`, plus the token is bound upstream (Wonder DA `bind_apn_token`, best-effort, `upstream_bound`) once the supplier order exists so Wonder's own updates reach the same activity. `GET` lists, `DELETE ?push_token=` ends.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • push_token (body, string, required)
  • activity_id (body, string)
POST/api/v1/me/rides/{id}/locationJEKStable
https://api.jek.app
Publish the passenger's live position
The mirror of /api/v1/da/location: the passenger shares their fix with the assigned driver, only while a driver is coming. Treated as a home address — caller's own ride only, live window enforced, DELETE stops sharing immediately.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • lat (body, number, required)
  • lng (body, number, required)
GET/api/v1/me/rides/{id}/locationJEKStable
https://api.jek.app
Read the passenger's shared position / visibility
Auth
user_bearer
Parameters
  • id (path, uuid, required)
DELETE/api/v1/me/rides/{id}/locationJEKStable
https://api.jek.app
Stop sharing the passenger's position
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/rides/{id}/ratingJEKStable
https://api.jek.app
Read the rating given for a trip
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/rides/{id}/ratingJEKStable
https://api.jek.app
Rate a completed trip
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • rating (body, number, required)
  • comment (body, string)
GET/api/v1/me/rides/{id}/related-activitiesJEKStable
https://api.jek.app
Recorded payments for the caller's owned ride or wish
JEK session and explicit X-JEK-Env required. Reads Supabase payment legs matched by user_id, exact metadata.ride_id and metadata.payment_env, after checking parent ride ownership, app scope and exact environment. No Wonder customer login or upstream history call. Returns { data: { ride_id, activities: [{ id, ride_id, purpose, amount, currency, status, occurred_at }] } }. Unavailable storage returns 503; no recorded payments returns an empty list. Private, no-store.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/rides/{id}/receiptJEKStable
https://api.jek.app
Itemised receipt for a ride
An itemised account of what the ride cost and what was actually charged, assembled from the transaction rows and the sealed pricing pin stored at booking. It reports; it does not re-price — editing the rate card later cannot rewrite an issued receipt. `format=html` returns the same receipt as a self-contained printable page (text/html, private, no-store) for the app to show, share, or print to PDF on the device; its language is `lang`, else the account's saved language, else English.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • format (query, "json" | "html")
  • lang (query, "en" | "zh-HK" | "zh-CN" | "ja" | "ko")
GET/api/v1/me/rides/{id}/tipJEKStable
https://api.jek.app
Read the tip left on a trip
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/rides/{id}/tipJEKStable
https://api.jek.app
Tip the driver after the trip
Adds money for the driver once the trip is finished — the mirror image of /boost, which is only legal while the ride is still waiting. Same ownership check and payment ledger as boost.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • amount (body, number, required)
POST/api/v1/me/rides/{id}/payment-orderJEKStable
https://api.jek.app
Open the ride's Wonder payment order (in-app SDK)
Creates ONE Wonder payment order for the ride and returns its `number` plus the `client_secret` the in-app Wonder Payment SDK renders its payment sheet against — no card data, token or 3DS step touches this server. The fare is one `Charge` line and each voucher is a NEGATIVE `Charge` line beside it, so the passenger owes the discounted total and the order itself records why; `jek_rides.fare` is untouched because it is the driver's payout basis. Call it when the passenger is about to pay, not at booking: the client_secret expires in about two hours and Wonder offers no way to mint a second one for an existing order, so a repeat call answers with the order but `client_secret_available: false`. Idempotent by construction — the order is keyed at Wonder on the ride id, and Wonder refuses a duplicate reference, so one ride can never have two orders. 409 FREE_RIDE when a voucher covers the whole fare. Card payment is open on EVERY declared environment — dev and staging hit gateway-stg where no real money moves, while alpha and production share one payment appId and both bill Jek Limited's real merchant record, so alpha is not a rehearsal. Only two things close it: `JEK_RIDE_PAYMENT_ORDERS_ENABLED=0` as an emergency stop, and an environment that has not declared itself, which cannot name the gateway it would bill.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/rides/{id}/payment-orderJEKStable
https://api.jek.app
Was the ride paid for? (and record it)
Reads the merchant's own order back from Wonder and, when it reports the money arrived, records the fare leg in jek_payment_charges. THE ORDER IS THE AUTHORITY: a client saying the payment sheet succeeded is a claim, `correspondence_state` on Jek Limited's order is a fact. Safe to poll — the charge row is keyed on the ride and leg, so one payment is recorded once however many times this is called. Answers `{data: null}` when no order has been opened.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/couponsJEKStable
https://api.jek.app
List the caller's ride coupons
With no `status`: this app's live coupons, the caller's exhausted ones included with `usable:false` (unchanged). `status=usable` drops the exhausted ones; `status=expired` lists coupons that lapsed in the last 90 days; `status=used` lists the caller's spends newest first, each with `ride_id`, `used_at`, `amount_off`, `fare_before` and `passenger_pays` as charged. Every item carries `state`: usable | used_up | expired | not_started | inactive. Unknown `status` is 400.
Auth
user_bearer
Parameters
  • status (query, "usable" | "expired" | "used")
GET/api/v1/me/coupons/{code}JEKStable
https://api.jek.app
One coupon with its full rules and the caller's state
Any state — usable, used_up, expired, not_started, inactive — with discount type/value, cap, minimum fare, eligible classes, validity window, terms keys and the caller's usage. Searched in this app's catalogue only; an unknown code (or the other brand's) is 404 `coupon_not_found`.
Auth
user_bearer
Parameters
  • code (path, string, required)
POST/api/v1/me/couponsJEKStable
https://api.jek.app
Price a coupon against a specific trip
Server-side 'HK$230, less HK$40 = HK$190' for the booking screen: prices the selection from the rate card (the same priceSelection the quote and booking routes use) and applies the coupon rule. The request never carries a fare, so the discount cannot be chosen by the client.
Auth
user_bearer
Parameters
  • coupon_id (body, uuid, required)
  • vehicleTypeId (body, uuid, required)
  • distanceKm (body, number, required)
POST/api/v1/passenger/trips/{id}/{action}JEKStable
https://api.jek.app
Trip lifecycle action (driver and passenger)
Multiplexed state-machine action endpoint. Passenger actions and driver actions (arrived, start, end) share the route; the caller's role decides which transitions are allowed.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • action (path, string, required)
GET/api/v1/passenger/transactionsJEKDeprecated
https://api.jek.app
Retired passenger history; use JEK self service
Deprecated · Returns 410 WONDER_HISTORY_RETIRED. Use /api/v1/me/rides, /api/v1/me/activity and /api/v1/me/rides/{id}/related-activities with the JEK session and explicit X-JEK-Env.
Auth
user_bearer
POST/api/v1/me/ride-booking-requests/resolveJEKStable
https://api.jek.app
Resolve an uncertain ride booking by its original booking key
Returns status found with ride_id, or not_created after durably closing the absent key so a delayed original request cannot create a ride. Scoped to the caller, product and environment. Returns 503 BOOKING_RECOVERY_UNAVAILABLE when the original outcome cannot be confirmed.
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
  • booking_key (body, string, required)
GET/api/v1/me/payment/cardsJEKStable
https://api.jek.app
List the caller's saved cards, shared with the legacy JEK app
Reads the caller's card vault at the payment gateway for the declared environment and answers `{ customerId, cards, shared_with_legacy }`; card tokens are stripped from every record. A JEK passenger linked (by verified phone) to their legacy JEK account has two payment customers, the legacy app's and this server's own: both are read, each card carries `customer_source` (`legacy` | `jek`), only one default is shown, and `customerId` is the legacy one. `partial: true` when one customer could not be read. The list is also kept in Supabase (`jek_payment_cards`) without card numbers or tokens (docs/75). Where this deployment collects no card payments the answer is an empty list with `collects: false` and `code: PAYMENT_COLLECTION_CLOSED`. 400 `ENV_NOT_DECLARED` without `x-jek-env`.
Auth
user_bearer
Parameters
  • x-jek-env (header, string, required)
  • x-jek-channel (header, string)
POST/api/v1/me/payment/cardsJEKStable
https://api.jek.app
Save a card, or sign an Alipay / WeChat Pay auto-debit agreement
The card number is sealed into the vault envelope and never stored or logged by this server. A passenger linked to their legacy JEK account saves to the legacy app's payment customer, so the card shows in both apps (`card.customer_source`, `shared_with_legacy`). Returns 201 with `state`; when the bank requires 3-D Secure, `verification_required` is true and the app must open `verify_url`, then call POST /api/v1/me/payment/cards/verify with `verify_uuid`. `usable` is false while the card is still pending. With `method: "alipay" | "wechat"` it signs an auto-debit agreement instead, answering in the same shape plus `instrument`, `handoff` and (WeChat) `wechat_session_id`. A refused card or agreement is 402 with the gateway's own message.
Auth
user_bearer
Parameters
  • x-jek-env (header, string, required)
  • x-jek-channel (header, string)
  • number (body, string)
  • exp_month (body, string)
  • exp_year (body, string)
  • cvv (body, string)
  • holder_name (body, string)
  • phone (body, string)
  • method (body, string)
  • return_url (body, string)
  • terminal_type (body, string)
  • code (body, string)
  • openid (body, string)
  • diagnose (body, boolean)
PATCH/api/v1/me/payment/cardsJEKStable
https://api.jek.app
Make a saved card the default
Sets the default card on the payment customer that holds it and confirms it by re-reading the vault. For a passenger shared with the legacy JEK app, a card on the legacy customer becomes the default in both apps. The default is what a fare is charged to when a payment names no card. Answers the updated `{ customerId, cards }`; 409 `CARD_NOT_FOUND` when the card is no longer on the account.
Auth
user_bearer
Parameters
  • x-jek-env (header, string, required)
  • card_id (body, string, required)
DELETE/api/v1/me/payment/cardsJEKStable
https://api.jek.app
Remove a saved card
Removes one card from the payment customer that holds it (the id travels in the body, not the path, because card ids are not URL-safe) and confirms by re-reading the vault. A card shared with the legacy JEK app is removed from both apps. Answers the remaining `{ customerId, cards, removed: true }`; 409 `CARD_NOT_FOUND` when the card is already gone.
Auth
user_bearer
Parameters
  • x-jek-env (header, string, required)
  • card_id (body, string, required)
POST/api/v1/me/payment/cards/verifyJEKStable
https://api.jek.app
Check whether a 3-D Secure or agreement save completed
Called after the passenger returns from the 3-D Secure challenge or the Alipay / WeChat consent page. Re-reads the vault and answers `{ verified, state, card, cards }`. When `return_query` is sent, the auto-debit authorization is applied first and its outcome is reported as `auth_apply`.
Auth
user_bearer
Parameters
  • x-jek-env (header, string, required)
  • verify_uuid (body, string)
  • card_id (body, string)
  • return_query (body, string)
  • diagnose (body, boolean)
GET/api/v1/me/payment/methodsJEKStable
https://api.jek.app
What the merchant accepts, for the payment picker
Describes the collecting merchant, not the caller: `methods`, `merchant`, the raw `rules` (Apple Pay and Google Pay appear there as card entry types, not as methods), `wallets` this build can finish, and `google_pay` tokenization parameters. Nothing is charged. When collection is closed the lists are empty with `collects: false`.
Auth
user_bearer
Parameters
  • x-jek-env (header, string, required)
  • handoffs (query, string)
GET/api/v1/me/payment/outstandingJEKStable
https://api.jek.app
Fares the caller still owes
Finds rides whose settlement failed or is unpaid and confirms each against its live payment order before reporting it, so a fare that has since been taken is never shown as owed. Answers `{ fares: [{ ride_id, amount, currency, vehicle, completed_at }], more, total }`, at most 5 fares; pay one with POST /api/v1/me/rides/{id}/pay.
Auth
user_bearer
POST/api/v1/me/rides/{id}/payJEKStable
https://api.jek.app
Hold or take a ride's fare with a saved card
`mode: "authorize"` (default) pre-authorizes the fare at booking; `mode: "settle"` takes what is still outstanding when the trip is over, capturing an existing hold where there is one. Creates the ride's payment order if the booking deferred it. The answer is read back from the order: `held` and `paid` are separate, and a hold is not a payment. 402 `AUTHORIZATION_DECLINED` / `PAYMENT_DECLINED` with the gateway's message; 409 `PAYMENT_ENV_MISMATCH` when the ride's money is at a different environment than the one declared.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • x-jek-env (header, string, required)
  • mode (body, string)
  • saved_card_id (body, string)
POST/api/v1/me/rides/{id}/pay/native-walletJEKStable
https://api.jek.app
Hold a ride's fare with an Apple Pay or Google Pay token
Redeems the one-time token from the OS payment sheet against the ride's payment order as a hold, then releases the `awaiting_payment` ride to drivers. The ride is dispatched only when the order confirms the hold; otherwise 402 `AUTHORIZATION_NOT_HELD`. Retrying after a hold landed answers success with `already` rather than holding twice. The token is never stored or logged.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • x-jek-env (header, string, required)
  • method (body, string, required)
  • token (body, string, required)
  • merchant_identifier (body, string)
POST/api/v1/me/rides/{id}/pay/walletJEKStable
https://api.jek.app
Start paying a ride's fare with a wallet app
Settles (never holds) the outstanding fare on WeChat Pay, Alipay, AlipayHK, PayMe, Octopus, FPS or the UnionPay wallet. The payment finishes in the wallet app, so the answer is always `paid: false, pending: true` with a `handoff` telling the client which of `redirect`, `qr`, `sdk_payload` or `wechat_pay` to use; poll GET on this route for the result. `amount` is what was actually charged (Octopus rounds up to the next 10 cents, shown in `rounding`).
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • x-jek-env (header, string, required)
  • method (body, string, required)
  • handoffs (body, string[])
  • return_url (body, string)
  • return_urls (body, object)
  • wechat_app_id (body, string)
  • app_env (body, string)
GET/api/v1/me/rides/{id}/pay/walletJEKStable
https://api.jek.app
Poll a wallet payment
Reads the ride's payment order and answers `{ order, paid, pending }`. When the order reads paid, the charge is recorded and the ride marked paid on this call. 409 `NO_PAYMENT_ORDER` when no payment has been started.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • x-jek-env (header, string, required)
POST/api/v1/me/rides/{id}/end-previewJEKStable
https://api.jek.app
Preview what ending the trip now would settle at
Computes, without ending the trip, the served distance and duration, the final total and any refund or additional charge, and returns them with a signed `preview_ref` and `expires_at` for POST /api/v1/me/rides/{id}/end to spend. The end point is the driver's last reliable position; the passenger's `location` is only a cross-check (`location_agrees`). Answers `allowed: false` with a reason when the trip cannot be ended; `settlement.simulated` is true where no refund rail is live.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • location (body, object)
  • reason_code (body, string)
PATCH/api/v1/me/rides/{id}/scheduleJEKStable
https://api.jek.app
Move a scheduled ride to another time
Changes the pickup time of the caller's own unclaimed scheduled ride; moves no money and keeps the booked fare (`quote.repriced` is always false, `quote.card_fare` shows today's card price for reference). A ride already released to drivers is taken back out of the pool until its new time (`withdrawn_from_pool`). The new time follows the booking's rules: at least 15 minutes ahead and within 30 days. 409 when a driver accepted in the meantime.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • scheduled_at (body, number | string, required)
POST/api/v1/me/rides/{id}/stops-previewJEKStable
https://api.jek.app
Preview a new remaining itinerary and its price
Prices distance already served plus the proposed remaining route from where the car is, without changing the ride. `stops` is the complete list of places still to visit (reached stops are kept automatically and cannot be edited). Returns the route, ETA, stops, `money` (new total, refund or additional charge) and a signed `preview_ref` for POST /api/v1/me/rides/{id}/stops. 409 `PLAN_CHANGED` when `plan_version` is stale.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • stops (body, object[], required)
  • dropoff (body, object)
  • plan_version (body, integer)
POST/api/v1/me/rides/{id}/stopsJEKStable
https://api.jek.app
Commit a previewed itinerary change
Applies exactly what a `preview_ref` from stops-preview carries, without recomputing it. The write is conditional on the plan version, so a concurrent change answers 409 `PLAN_CHANGED` with the current plan instead of being overwritten; an expired preview is refused. Records the revision and the fare difference, and notifies the assigned driver. 400 `PREVIEW_REQUIRED` without a valid preview.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • preview_ref (body, string, required)
  • idempotency_key (body, string)
  • Idempotency-Key (header, string)
DELETE/api/v1/passenger/trips/{id}/locationJEKStable
https://api.jek.app
Stop sharing the passenger's location
Deletes the trip's current passenger fix and clears it from the trip's tracking block, so the driver no longer sees it. Answers `{ ok: true, relayed_to_driver: false }`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
DELETE/api/v1/passenger/trips/{id}/shareJEKStable
https://api.jek.app
Revoke trip share links
Revokes one share link when `id` is given, otherwise every share link the caller issued for this trip.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • id (query, uuid)
DELETE/api/v1/passenger/trips/{id}/sosJEKStable
https://api.jek.app
Resolve an open SOS
Marks the caller's open SOS event resolved. 404 when no open SOS has that id.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • event_id (query, uuid, required)
DELETE/api/v1/passenger/trips/{id}/live-activityJEKStable
https://api.jek.app
End the trip's Live Activity
Ends the iOS Live Activity for this trip, on the device named by `push_token` or on all of the caller's devices. The final phase follows the trip status when it is terminal, otherwise `cancelled`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • push_token (query, string)
Driver Assistant
GET/api/v1/da/wishesJEKStable
https://api.jek.app
List open wishes near the driver
The driver's whole wish surface in one read: `data` is the open pool (no driver yet), `mine` is every wish the caller holds in any state, and `can_accept` says whether a claim from this driver would be allowed at all. Rows are sanitised for the driver — the passenger's `fare` and the `wish.pricing` pin are stripped — and only `mine` carries passenger contact details.
Auth
driver_bearer
POST/api/v1/da/wishes/{id}/acceptJEKStable
https://api.jek.app
Accept a wish
Claims a wish, first driver wins via a conditional update on `driver_id`. Returns `{ data, served_vehicle_class, refunded? }` where `data` is the full claimed wish row with `status: "accepted"` — clients render from it rather than re-reading the feed. Refuses with 403 when the driver is not eligible to take work or their active vehicle serves no class the order accepts, and 409 "Wish already taken" when another driver got there first. Unlike the list endpoint, the row returned here is RAW, so a driver-facing relay must strip `fare` and `wish.pricing` itself.
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/da/meJEKStable
https://api.jek.app
Driver profile & onboarding state
Returns the signed-in driver, their vehicles, documents and an onboarding checklist. The profile is provisioned automatically on first call.
Auth
driver_bearer
PATCH/api/v1/da/meJEKStable
https://api.jek.app
Update driver profile
Auth
driver_bearer
Parameters
  • display_name (body, string)
  • phone_e164 (body, string)
POST/api/v1/da/me/onlineJEKStable
https://api.jek.app
Go online / offline
Only approved drivers with an active vehicle may go online.
Auth
driver_bearer
Parameters
  • is_online (body, boolean, required)
GET/api/v1/da/vehiclesJEKStable
https://api.jek.app
List the driver's vehicles
Auth
driver_bearer
POST/api/v1/da/vehiclesJEKStable
https://api.jek.app
Register a vehicle
Auth
driver_bearer
Parameters
  • plate_number (body, string, required)
  • model_name (body, string)
  • color (body, string)
  • seats (body, integer)
  • vehicle_type_code (body, string)
  • vehicle_type_codes (body, string[])
PATCH/api/v1/da/vehicles/{id}JEKStable
https://api.jek.app
Update or activate a vehicle
Send is_active=true to make this the vehicle used for new orders. Sending vehicle_type_codes REPLACES the approved class set rather than adding to it, so a class claimed in error can be taken back.
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
  • is_active (body, boolean)
  • plate_number (body, string)
  • model_name (body, string)
  • color (body, string)
  • seats (body, integer)
  • vehicle_type_code (body, string)
  • vehicle_type_codes (body, string[])
DELETE/api/v1/da/vehicles/{id}JEKStable
https://api.jek.app
Remove a vehicle
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/da/documents/upload-urlJEKStable
https://api.jek.app
Signed upload URL for a document
Returns a short-lived URL; PUT the file to it, then register it with POST /api/v1/da/documents.
Auth
driver_bearer
Parameters
  • doc_type (body, string, required)
  • file_name (body, string, required)
POST/api/v1/da/documentsJEKStable
https://api.jek.app
Submit a document for review
Auth
driver_bearer
Parameters
  • doc_type (body, string, required)
  • storage_path (body, string, required)
  • document_number (body, string)
  • expires_on (body, date)
GET/api/v1/da/documentsJEKStable
https://api.jek.app
List submitted documents
Auth
driver_bearer
GET/api/v1/da/offersJEKStable
https://api.jek.app
Pending order offers
Live offers for the signed-in driver. Empty while offline or when onboarding is incomplete.
Auth
driver_bearer
POST/api/v1/da/offers/{id}/acceptJEKStable
https://api.jek.app
Accept an offer
First accept wins; a losing caller receives 409 Order already taken.
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/da/offers/{id}/declineJEKStable
https://api.jek.app
Decline an offer
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
  • reason (body, string)
GET/api/v1/da/orders/activeJEKStable
https://api.jek.app
Current in-flight order
Auth
driver_bearer
POST/api/v1/da/orders/{id}/statusJEKStable
https://api.jek.app
Advance the order state
accepted → arrived → in_trip → completed (cancel allowed before in_trip). Completing an order writes the earnings row and mirrors the state to the rider platform.
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
  • state (body, string, required)
  • reason (body, string)
GET/api/v1/da/ordersJEKStable
https://api.jek.app
Order history
Auth
driver_bearer
Parameters
  • state (query, string)
  • from (query, date-time)
  • to (query, date-time)
  • limit (query, integer)
  • offset (query, integer)
POST/api/v1/da/locationJEKStable
https://api.jek.app
Location ping
Updates the driver's live position and, when on a trip, the trail shown to the rider.
Auth
driver_bearer
Parameters
  • latitude (body, number, required)
  • longitude (body, number, required)
  • heading (body, number)
  • speed_kph (body, number)
  • accuracy_m (body, number)
POST/api/v1/da/push-tokensJEKStable
https://api.jek.app
Register the driver's device for JEK pushes
Enrolls native APNs/FCM devices in Wonder Replyx. Requires the sealed x-da-session; app, account and environment are server-derived. No app secret is returned. Staging and production are isolated; alpha has no configured Replyx app. DELETE ?registration_id= retires the exact caller/session binding; revoked sessions cannot receive future notifications.
Auth
driver_bearer
Parameters
  • provider (body, string, required)
  • device_id (body, uuid, required)
  • push_token (body, string, required)
  • platform (body, string, required)
GET/api/v1/da/earningsJEKStable
https://api.jek.app
Earnings summary and line items
Minor units. Lines carry `source`: `order` (partner orders), `wish`, `ride`, and `tip` — each collected, unrefunded passenger tip as its own line, 100% to the driver, the same figure settlement pays. Tips count in `today_net` / `week_net` but not in `trips_today`. Days and weeks are Hong Kong's. With `from` (and `to`, default now) the read is a window: every line earned in it, unpaged (cap 2000, `meta.truncated`).
Auth
driver_bearer
Parameters
  • from (query, date-time)
  • to (query, date-time)
  • limit (query, integer)
  • offset (query, integer)
GET/api/v1/da/next-payoutJEKStable
https://api.jek.app
What tonight's settlement run is expected to pay the driver
Read-only forecast that mirrors the nightly settlement run (00:00–00:59 HKT): `expected_minor` (accrued, payable legs the run will batch plus open batches not under review, less open clawbacks; per business in `businesses`), `held` (with a reason: `receipt_review`, `passenger_payment`, `partner_unpaid`, `under_review`, `payout_failed`, `account_issue`, `checking`), and `sending_minor` (transfers Wonder has not answered). `status` is `settling` during the run's hour, else `scheduled`; `run_at` is that run's start. Scoped to the caller's environment (alpha + production together). Subject to the run's final checks — the paying account's balance and Wonder's answer are only known then.
Auth
driver_bearer
POST/api/v1/da/wishes/{id}/statusJEKStable
https://api.jek.app
Advance a wish order's status
Driver-side state transition for a wish the caller holds: accepted → arrived → in_trip → completed, with cancelled available until the trip starts. The body field is `state`, NOT `status`. Returns `{ data }` — the full updated wish row, which is what the driver app renders from rather than re-reading the feed. Refuses a disallowed move with 409 `{ error, allowed: [...] }` naming the transitions it would have accepted, 409 "Wish changed concurrently" if the status moved under the caller, and 404 for a wish the caller does not hold.
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
  • state (body, string, required)
  • reason (body, string)
GET/api/v1/da/wishes/{id}JEKStable
https://api.jek.app
Wish order detail for the assigned driver
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/da/wishes/{id}/expenseJEKStable
https://api.jek.app
List expense claims filed against a wish
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/da/wishes/{id}/expenseJEKStable
https://api.jek.app
File an expense claim for reimbursement
Submits an out-of-pocket expense (amount, note, uploaded receipt path) for the wish the driver is running.
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
  • amount (body, number, required)
  • receiptPath (body, string)
  • note (body, string)
POST/api/v1/da/wishes/{id}/expense/upload-urlJEKStable
https://api.jek.app
Signed upload URL for an expense receipt
Returns a short-lived signed URL into the driver-documents bucket for the receipt image.
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/da/wishes/{id}/messagesJEKStable
https://api.jek.app
Read the passenger chat thread for a held order (driver)
The driver's side of the thread `POST /api/v1/me/rides/{id}/contact {channel:'chat'}` opens. Only for an order this driver holds (`driver_id`); `can_post` reflects the same liveness gate the passenger side applies. `viewer_id` is the caller's own messaging id — compare it with a message's `sender_id` to tell their messages from the passenger's; a client has no other way to learn what JEK calls it.
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
  • limit (query, number)
  • before (query, string)
POST/api/v1/da/wishes/{id}/messagesJEKStable
https://api.jek.app
Reply to the passenger (driver)
Sends into the ride's thread, creating it if the passenger has not opened it yet. Only while the driver holds a live order — 409 `RIDE_NOT_LIVE` otherwise. The passenger is pushed the message like any other.
Auth
driver_bearer
Parameters
  • id (path, uuid, required)
  • body (body, string, required)
GET/api/v1/da/vehicle-catalogueJEKStable
https://api.jek.app
Vehicle catalogue for driver registration
Makes / models / classes a driver can bind to their vehicle; the same catalogue M1OS servicing uses.
Auth
driver_bearer
GET/api/v1/da/jobs/realtimeJEKStable
https://api.jek.app
Get connection parameters for private driver job updates
Requires the driver's environment-bound session. Returns the public realtime URL/key and authorized environment and driver topics. Subscribe using the existing driver bearer; no passenger or order data is returned by this endpoint.
Auth
driver_bearer
POST/api/v1/da/app-update/checkJEKStable
https://api.jek.app
Check for a newer native build
Asks the Wonder App Manager whether a newer Driver Pro binary exists for the device's channel and returns the APK download when one is on offer. Works before sign-in; any upstream failure answers `updateAvailable: false` rather than an error.
Auth
no auth
Parameters
  • os (body, string, required)
  • build (body, integer, required)
  • x-wonder-env (header, string)
GET/api/v1/da/jobsJEKStable
https://api.jek.app
Combined job feed
One feed of open consumer rides, wishes and partner (supplier) bookings in `data`, plus the jobs the driver already holds in `mine`. Each item carries `source` (`consumer` or `supplier`); when the driver cannot take work, `data` is empty and `blocked_reason` says why.
Auth
driver_bearer
GET/api/v1/da/overlay-feedJEKStable
https://api.jek.app
Android floating-card feed
Bare array of open jobs, polled every four seconds by the Android overlay service while the app is backgrounded. Every refusal (blocked driver, superseded session, no environment) answers `[]` rather than an error.
Auth
driver_bearer
Parameters
  • x-wonder-env (header, string)
  • x-da-session (header, string)
DELETE/api/v1/da/push-tokensJEKStable
https://api.jek.app
Retire a push token
Soft-deletes the caller's own row for the given Expo token, typically on sign-out.
Auth
driver_bearer
Parameters
  • expo_token (query, string, required)
POST/api/v1/da/wishes/{id}/stops/{stopId}/reachedJEKStable
https://api.jek.app
Mark a stop reached
Marks a planned stop on a held job as reached, which locks it against passenger edits. Only while the job is `arrived` or `in_trip`; idempotent and cannot be undone.
Auth
driver_bearer
Parameters
  • id (path, string, required)
  • stopId (path, string, required)
Public
GET/api/public/explore-merchantsJEKStable
https://api.jek.app
Merchants for the Explore map
Auth
no auth
GET/api/public/merchant-detailJEKStable
https://api.jek.app
Public merchant profile
Auth
no auth
Parameters
  • slug (query, string, required)
POST/api/public/social-summaryJEKStable
https://api.jek.app
AI summary of a merchant's public reviews
Auth
no auth
Dispatch
POST/api/public/v1/dispatch/ordersJEKStable
https://api.jek.app
Create a dispatch order from a demand platform
Token-authenticated integration endpoint. All channels funnel into the same supplier order queue.
Auth
no auth
POST/api/public/v1/dispatch/orders/{id}/cancelJEKStable
https://api.jek.app
Cancel a dispatch order
Auth
no auth
Merchants
GET/api/public/v1/merchantsJEKStable
https://api.jek.app
List merchants
Search & filter public merchant directory.
Auth
no auth
Parameters
  • q (query, string)
  • cuisine (query, string)
  • limit (query, integer)
GET/api/public/v1/merchants/{slug}JEKStable
https://api.jek.app
Merchant detail
Auth
no auth
Parameters
  • slug (path, string, required)
GET/api/public/v1/merchants/{slug}/socialsJEKStable
https://api.jek.app
Merchant social profiles
Auth
no auth
Parameters
  • slug (path, string, required)
GET/api/public/v1/chains/{id}JEKStable
https://api.jek.app
Chain detail + member merchants
Auth
no auth
Parameters
  • id (path, uuid, required)
GET/api/v1/explore/placesJEKStable
https://api.jek.app
JEK merchants and Apple / Google Maps places near a point
No sign-in. `?lat&lng&radius_m (100–5000)&category (eat|cafes|bars|shops|go-out)&q&jek_only=1&limit (≤100)&offset`. Items `{id (m:<merchant>|a:<Apple place>|g:<Google place>), kind: jek|apple|google, name, address, lat, lng, distance_m, category, rating, rating_count, price_level, open_now, photo, capabilities{book, reserve, preorder, vouchers, kash}, enrichment?, provider_attribution?}` — for a non-JEK place every capability but `book` is false; `book` = JEK can drive the passenger there (a coordinate inside Hong Kong). `provider_attribution` ("Apple Maps" on Apple data) must be shown. Nearest first; a venue listed by several sources appears once (merchant, else Apple, else Google). From the database; an unsearched area is searched with Apple Maps (Hong Kong only) under the day's Apple call cap — `apple_budget_exhausted` when that cap stopped it. Explore's Google calls are off by default (docs/80); `google_budget_exhausted` is today's Google cap from the day's counter, false while Google is off.
Auth
no auth
Parameters
  • lat (query, number)
  • lng (query, number)
  • radius_m (query, number)
  • category (query, string)
  • q (query, string)
  • jek_only (query, boolean)
  • limit (query, number)
  • offset (query, number)
GET/api/v1/explore/places/{id}JEKStable
https://api.jek.app
One Explore place in full (JEK merchant + Apple place + cached Google details)
No sign-in. `id` from the list (`m:` / `a:` / `g:`). `merchant`, `google` (cached hours, reviews with authors, photos with attributions — Google requires both shown — attributes, Google Maps link), `apple` (the Apple Maps place), `enrichment` (hours / photos / address / summary / website / phone, each `{value, source: website|google|unverified, at}`), `enrichment_status`, `provider_attribution` ("Apple Maps" must be shown with Apple data) and `capabilities{book, reserve, preorder, vouchers, kash}`. With Explore's Google off (the default, docs/80) nothing is refreshed on view and expired Google photo URIs are left out; a copy past its refresh period says `stale: true`. With Google on, a stale copy is refreshed first (≤ ~3 s, under budget); `google_budget_exhausted` when today's cap is spent.
Auth
no auth
Parameters
  • id (path, string, required)
GET/api/v1/explore/top-picksJEKStable
https://api.jek.app
Explore top picks near a point
No sign-in. `?lat&lng&category&limit (≤30)`. JEK merchants first, then by rating weighted by rating count (Apple places carry no rating). Items as in `/api/v1/explore/places` (kinds jek|apple|google, with `capabilities.book`). Database only, no Apple or Google call; `google_budget_exhausted` is today's Google budget state from the day's counter, false while Explore's Google is off.
Auth
no auth
Parameters
  • lat (query, number)
  • lng (query, number)
  • category (query, string)
  • limit (query, number)
GET/api/public/v1/explore/searchJEKStable
https://api.jek.app
Explore search: JEK merchants + Apple Maps + cached places
No sign-in (docs/80). `?q&lat&lng&radius (metres, 100–5000, default 2000)&category (eat|cafes|bars|shops|go-out)&limit (≤100, default 30)`. JEK merchants and cached Apple / Google places; with `q` and Apple enabled, also a live Apple Maps search (Hong Kong only, under the day's Apple call cap), stored and merged. A venue found by several sources appears once (merchant, else Apple, else Google). Answers `{data: {items, apple_budget_exhausted, sources: (jek|apple|google)[]}}`; items as in `/api/v1/explore/places` — `a:` ids for Apple, `provider_attribution: "Apple Maps"` must be shown, a non-JEK place offers only `capabilities.book`. Never calls Google.
Auth
no auth
Parameters
  • q (query, string)
  • lat (query, number)
  • lng (query, number)
  • radius (query, number)
  • category (query, string)
  • limit (query, number)
GET/api/public/v1/explore/places/{id}JEKStable
https://api.jek.app
One Explore place in full, with its enrichment
No sign-in (docs/80). `id` is `m:<merchant>`, `g:<Google place>` or `a:<Apple place>`, as the search returns it. The same body as `/api/v1/explore/places/{id}`: `merchant`, `google`, `apple`, `enrichment` (each field `{value, source: website|google|unverified, at}` — label `unverified` values as such), `enrichment_status`, `provider_attribution`, `capabilities`, `stale`. Database only: a place not enriched yet is enriched by the cron, never while the viewer waits.
Auth
no auth
Parameters
  • id (path, string, required)
Promotions
GET/api/public/v1/vouchersJEKStable
https://api.jek.app
List vouchers
Published merchant vouchers, soonest-ending first (≤200). `?merchant_id` narrows to one merchant's own vouchers and the ones linked to it. `starts_at` / `ends_at` are the voucher's validity window. To hold one, claim it: POST /api/v1/me/vouchers/claim.
Auth
no auth
Parameters
  • merchant_id (query, string)
GET/api/public/v1/promotionsJEKStable
https://api.jek.app
Active promotions
Published vouchers running now: started, and not ended (`ends_at` null means open-ended). Soonest-ending first, ≤100.
Auth
no auth
Ride
GET/api/public/v1/ride/vehicle-typesJEKStable
https://api.jek.app
Available vehicle types
The rate card, already in the order a passenger should read it: Standard, Express, Meter, 85% Meter, Premium, 6-seater, Wheelchair, Extra Luggage, then anything else by name. Render the array as it arrives. A client that must re-sort may only sort by `sort_order` — the operator's own ordering from /admin/ride/vehicle-types, which this response already honours — never by name or price, which is a different running order for the app.
Auth
no auth
POST/api/v1/ride/priceJEKStable
https://api.jek.app
What paying this way would cost (coupon + payment offer)
The legacy price_calculator, from JEK's own rules: the dearest fare of the selection, less the coupon (the booking's own test), less the payment offer for `payment_method` / `card_scheme`, plus `tip` (never discounted). The fare is priced from exactly one basis: `quote_ref` (a signed /api/v1/ride/quote answer — verified like the booking verifies it and re-priced from the card; 409 `QUOTE_STALE` / `QUOTE_INVALID` exactly where the booking would refuse it), `ride_id` (one of the caller's own rides — its booked `fare`, with any coupon it already spent; another passenger's ride is 404), or `vehicle_class_ids` + `distance_km`. Returns `{currency, basis, fare, coupon, payment_offer, tip, amount_due, lines[], estimate: true}`. A preview — nothing is spent; the booking decides again. Payment offers are only offered to callers that declare `x-jek-env` (the native apps), because only their pay routes can hold the method; a ride booked with an offer is refused by /pay, /pay/wallet and /pay/native-wallet with 409 PAYMENT_OFFER_METHOD_MISMATCH when paid another way.
Auth
user_bearer
Parameters
  • quote_ref (body, string)
  • ride_id (body, uuid)
  • vehicle_class_ids (body, uuid[])
  • distance_km (body, number)
  • duration_min (body, number)
  • tip (body, number)
  • coupon_code (body, string)
  • payment_method (body, string)
  • card_scheme (body, string)
POST/api/v1/ride/quoteJEKStable
https://api.jek.app
Estimate ride fare
Prices one vehicle type, or a whole selection. Send vehicle_class_ids to price several at once: the response adds `authorize`, the dearest of them, which is what the passenger pre-authorises so that whichever driver accepts, the fare is already covered. The selection is priced in one call on purpose — quoting each class separately would let the client decide which counted as dearest. A quote takes up to 24 ids — the whole rate card, so a price list is one call, no batching — while a booking accepts at most 6; the response echoes that as vehicle_class_limit. A class can have a MINIMUM FARE — 85% Meter Taxi is not offered below HKD 90, because a discounted short trip is a job no driver takes. On a trip that prices under it the class is dropped from `quotes` and listed in `withheld` with the floor it missed, so a price list drawn from `quotes` loses the row by itself. 400 BELOW_CLASS_MINIMUM when nothing clears its floor, or when vehicle_type_id named such a class; POST /api/v1/me/rides refuses the same class with the same code rather than dropping it, so a stale screen cannot book one. A multi-class quote also carries `coupon` — the best usable coupon on the dearest fare (largest discount, priced by the same test the booking runs), marked `estimate: true` because the booking prices it on the fare it actually authorises — and `coupon_quotes`, the price list with that coupon's effect per class. `authorize`, `quotes` and `quote_ref` stay undiscounted; to use the coupon, send its code as `coupon_code` to POST /api/v1/me/rides. `coupon: false` skips the lookup. JEK (docs/71 W1): a multi-class quote also carries `kash {balance, redeemable_max, earn_estimate}` — the passenger's JEK Kash, the most this booking could redeem (capped by the rules; 0 for the 85% meter taxi) and what the dearest class would earn — or null when Kash is off or the caller is not in the JEK app. An estimate; redeem with `kash_amount` on POST /api/v1/me/rides.
Auth
user_bearer
Parameters
  • vehicle_type_id (body, uuid)
  • vehicle_class_ids (body, uuid[])
  • distance_km (body, number, required)
  • duration_min (body, number)
POST/api/v1/me/rides/{id}/vehicle-classesJEKStable
https://api.jek.app
Accept more vehicle classes while waiting
Widens what an unmatched ride will accept. Only the DIFFERENCE is charged — the passenger already authorised the previous dearest class, so a cheaper addition costs nothing and a dearer one costs the gap. Widening only: classes are never removed, because that could strand a driver already on the way. 409 once a driver has taken it.
Auth
user_bearer
Parameters
  • vehicle_class_ids (body, uuid[], required)
POST/api/v1/me/rides/{id}/boostJEKStable
https://api.jek.app
Add money to an unmatched order
Raises the fare on an order no driver has taken. Wishes and ordinary rides both. Refused once a driver is attached.
Auth
user_bearer
Parameters
  • amount (body, number, required)
GET/api/v1/ridesJEKStable
https://api.jek.app
Signed-in user's ride history
Auth
user_bearer
GET/api/v1/ride/rating-reasonsJEKStable
https://api.jek.app
Rating reason catalog (managed, versioned)
The reason chips a finished Lane 1 trip offers, with a `catalog_version` derived from the catalog's content so a client can cache against it. Each entry carries `code`, `label_key` (a translation key the client resolves — the server never sends an English label, which would be wrong in three of the four shipped locales), an operator `label` override or null, and `sentiment`. Managed in `system_configs['ride.rating']` beside the rating windows; POST /api/v1/me/rides/{id}/rating validates against this same list, so an added reason is stored rather than dropped.
Auth
user_bearer
POST/api/v1/ride/preflightJEKStable
https://api.jek.app
May this trip be booked? (Lane 1 serviceability)
The authoritative Lane 1 answer Standard Ride and JEK Wish both run before opening a quote/request screen. 200 = serviceable, with the summed route (`distance_m`, `duration_min`, stitched `points`). 422 `OUT_OF_SERVICE_AREA` = definitively unsupported — a waypoint outside every configured service area, or a leg the router says has no road; refuse, do not retry. 503 `ROUTING_UNAVAILABLE` = temporary, offer Retry (never shown as "unavailable here"). 401 `AUTH_REQUIRED`. Service areas come from `system_configs['ride.service_area']`, shared with /api/v1/passenger/serviceability. `dropoff` is optional: with a pickup alone this answers the area question only, which is what a landing screen needs. No supply probe — that would sign with Wonder DA, which Lane 1 exists to avoid. Also returns `fulfilment` (`jek` = our own fleet, `partner` = third-party capacity through Wonder for a market where JEK has no fleet) and `fulfilment_area`. THE CLIENT READS THIS, IT NEVER DECIDES IT: a JEK passenger books through the same surface wherever they are standing, and the server picks the supplier from each area's `fulfilment`, maintained at /admin/ride/service-areas. The PICKUP decides — a Hong Kong pickup bound for Shenzhen is still `jek`. On `partner` our own service areas stop constraining the other waypoints (they describe where OUR fleet drives), though an undrivable leg still refuses. `fulfilment` is null on a 422 whose pickup nobody serves.
Auth
user_bearer
Parameters
  • order_type (body, string)
  • pickup (body, object, required)
  • dropoff (body, object)
  • stops (body, array)
POST/api/v1/ride/availabilityJEKStable
https://api.jek.app
Live supply and pickup ETA (Lane 1)
Is there a car for this pickup, which classes can serve it, and how long until one arrives — the third pre-booking question, beside /ride/preflight (may we drive here) and /ride/quote (what does it cost). Counts `da_drivers` that are online, approved, carrying a fix newer than 150s, inside the radius and not already on a job; a driver whose vehicle declares no dispatch class is UNRESTRICTED and counts for every class, exactly as the accept path reads it. Deliberately NOT /passenger/serviceability's probe, which signs with Wonder DA and counts street taxis that cannot take a jek_rides order. `supply.status`: `ok` (measured, cars) | `none` (measured, none) | `unavailable` (OUR outage — show a retry, never "no cars") | `not_applicable` (this area's `fulfilment` is partner/fleet, so our own fleet is not the answer). `eta` is the road route to the NEAREST car, falling back to the same straight-line estimate the live ride's `remaining_route` uses and labelled `source: estimate`; each class routes its own nearest eligible car, with parallel four-second timeouts and one call per distinct driver. Classes sharing a car share its ETA. A failed route falls back from that car's own coordinates with eta_source: estimate and eta_confidence: low. Never answers 5xx for an outage. This reports supply, it does NOT authorise a booking — /ride/preflight stays the coverage authority. Cached 10s on the rounded request.
Auth
user_bearer
Parameters
  • pickup (body, object, required)
  • vehicle_class_ids (body, uuid[])
  • radius_m (body, number)
POST/api/v1/ride/nearbyJEKStable
https://api.jek.app
Nearby cars on the map (Lane 1)
The pins the where-to map draws before anything is assigned: JEK's OWN drivers around a point, from the same `da_drivers` probe /ride/availability counts (online, approved, fix newer than 150s, inside the radius, not on a job) — with no routing call, so a map may poll it every 12s. Deliberately NOT /passenger/nearby, which proxies Wonder DA's taxis/nearby with partner credentials: that is the lane a JEK rider is handed down OUTSIDE Hong Kong, and it returns street taxis that cannot take a jek_rides order. `vehicles[]` is nearest first, capped at `limits.max_vehicles` (supply.count stays the true number); each `id` is a pseudonym that is stable across polls and rotates daily — never a driver id. `supply.status` as on /ride/availability: `ok` | `none` (measured, empty street) | `unavailable` (OUR outage — not an empty street, not cached) | `not_applicable` (this area's fulfilment is partner/fleet; somebody else's cars serve it). Never 5xx for an outage. Reports supply, does not authorise a booking. Cached 10s on the rounded request.
Auth
user_bearer
Parameters
  • pickup (body, object, required)
  • radius_m (body, number)
POST/api/v1/ride/directionsJEKStable
https://api.jek.app
Route geometry, distance & duration
Server-side Google Directions proxy. Returns an encoded polyline plus distance (metres) and duration (seconds) for a pickup → destination pair. Used by the booking wizard so the browser never needs a Maps key.
Auth
user_bearer
Parameters
  • origin (body, object, required)
  • destination (body, object, required)
POST/api/v1/ride/wish-analysisJEKStable
https://api.jek.app
Analyse a passenger 'wish' request
Runs the free-text (or transcribed voice) wish through the analysis model with the route context. Returns feasibility, whether it is really a plain ride, clarification questions, estimated extra time/cost and a suggested tip range.
Auth
user_bearer
Parameters
  • wish (body, string, required)
  • pickup (body, string)
  • destination (body, string)
  • distance_km (body, number)
  • base_fare (body, number)
POST/api/v1/ride/wish-quoteJEKStable
https://api.jek.app
Re-price an already-analysed wish
Recomputes a signed fare quote when the vehicle class or route changes after /api/v1/ride/wish-analysis, without re-running the language model. Wish facts sent by the client are clamped server-side, so a cheaper wish cannot be forced.
Auth
user_bearer
Parameters
  • vehicleTypeId (body, uuid, required)
  • distanceKm (body, number, required)
  • durationMin (body, number)
  • analysis (body, object)
Account
GET/api/v1/meJEKStable
https://api.jek.app
Current user + profile
Auth
user_bearer
GET/api/v1/me/activityJEKStable
https://api.jek.app
Recent transactions, rides, rewards
Auth
user_bearer
GET/api/public/v1/app-configJEKStable
https://api.jek.app
Must this app update, may it, and is the service in maintenance (public)
Called at startup, before sign-in. `update`: `required` below min_version (or at it with a build below min_build), `optional` below latest_version, else `none`. `maintenance.active` when switched on or inside its window; `upcoming` when a window starts within 7 days. Fails open: no config, an unconfigured platform or a malformed version answers `update:"none"` and no maintenance. Unknown `app`/`platform` is 400. Cached 60 s.
Auth
no auth
Parameters
  • app (query, "jek" | "hk_taxi_go")
  • platform (query, "ios" | "android", required)
  • version (query, string)
  • build (query, integer)
DELETE/api/v1/me/activityJEKStable
https://api.jek.app
Remove rides from the caller's ride history
Hides rides from the caller's own lists by stamping `passenger_hidden_at`; the ride row is kept, because it is also the driver's earnings record and the operator's audit trail. Name rides with `ride_id`, `ride_ids` or `all: true` (there is no default; `all` hides only finished rides). A named in-flight ride is refused with 409 and nothing in the batch is hidden; a ride that is not the caller's is 404 `RIDE_NOT_FOUND`. Answers `{ deleted, hidden, ids, refused }`; 503 `HISTORY_HIDE_UNAVAILABLE` on a database without the column.
Auth
user_bearer
Parameters
  • ride_id (body, uuid)
  • ride_ids (body, uuid[])
  • all (body, boolean)
  • ride_id (query, uuid)
Merchant Dashboard
GET/api/v1/merchant/meJEKStable
https://api.jek.app
Signed-in merchant record
Auth
merchant_bearer
GET/api/v1/merchant/vouchersJEKStable
https://api.jek.app
Vouchers owned by signed-in merchant
Auth
merchant_bearer
POST/api/v1/merchant/onboardJEKStable
https://api.jek.app
Claim / register a merchant profile
Auth
user_bearer
POST/api/v1/merchant/vouchersJEKStable
https://api.jek.app
Create voucher
Auth
merchant_bearer
PATCH/api/v1/merchant/vouchers/{id}JEKStable
https://api.jek.app
Update voucher
Auth
merchant_bearer
Parameters
  • id (path, uuid, required)
DELETE/api/v1/merchant/vouchers/{id}JEKStable
https://api.jek.app
Delete voucher
Auth
merchant_bearer
Parameters
  • id (path, uuid, required)
Contacts
POST/api/v1/me/contactsJEKStable
https://api.jek.app
Bulk upload contacts from a JEK user's phone
Accepts a batch of contacts (name + phone(s) + optional emails), normalizes each phone to E.164 using the provided default_country (e.g. "852"), and upserts them into jek_user_contacts scoped to the caller. Safe to call repeatedly — duplicates are merged by (user_id, phone_e164).
Auth
user_bearer
Parameters
  • contacts (body, Array<{ name?: string; phone?: string; phones?: string[]; emails?: string[] }>, required)
  • default_country (body, string)
  • source (body, string)
GET/api/v1/me/contactsJEKStable
https://api.jek.app
List uploaded contacts with on-JEK match
Returns the caller's uploaded contacts. Each contact carries an on_jek flag computed by matching phone_e164 against the JEK user directory server-side (via SECURITY DEFINER — no direct DB read from the client).
Auth
user_bearer
DELETE/api/v1/me/contactsJEKStable
https://api.jek.app
Clear all uploaded contacts (soft-delete)
Auth
user_bearer
GET/api/v1/me/referralJEKStable
https://api.jek.app
List the caller's invite codes (auto-creates a default)
Returns every active referral code the user owns plus the default one, each with invite.jek.app URL and WhatsApp/SMS share links. First call for a user lazily allocates a random 8-char default code (collision-safe).
Auth
user_bearer
POST/api/v1/me/referralJEKStable
https://api.jek.app
Create an additional invite code (campaign / channel)
Allocates a new random code owned by the caller. Useful for influencers or marketing campaigns that need to attribute installs per channel. Set make_default=true to promote it to the primary code.
Auth
user_bearer
Parameters
  • label (body, string)
  • campaign (body, string)
  • make_default (body, boolean)
PATCH/api/v1/me/referralJEKStable
https://api.jek.app
Promote a code to default, or soft-delete it
Auth
user_bearer
Parameters
  • id (body, uuid, required)
  • action (body, "set_default" | "delete", required)
GET/api/public/referral-lookupJEKStable
https://api.jek.app
Validate a referral code (public)
Called by invite.jek.app to confirm an inbound ?ref=CODE is real before showing it to the visitor and setting the attribution cookie. Never returns the owner's identity.
Auth
no auth
Parameters
  • code (query, string, required)
POST/api/public/referral-visitJEKStable
https://api.jek.app
Track a visit to invite.jek.app for attribution
Called by the invite.jek.app landing page whenever it loads with a valid ?ref=CODE. Increments the code's visit_count and records platform (ios/android/web), source, referrer and user-agent.
Auth
no auth
Parameters
  • code (body, string, required)
  • platform (body, "ios" | "android" | "web")
  • source (body, string)
  • referrer (body, string)
Messaging
GET/api/v1/me/messaging/conversationsJEKStable
https://api.jek.app
List the caller's conversations (inbox)
Returns every conversation the user is a member of, ordered by last_message_at. Each entry carries last_message_preview, unread_count, member list, and type (dm/group/agent/support).
Auth
user_bearer
POST/api/v1/me/messaging/conversationsJEKStable
https://api.jek.app
Start a DM, group, or JEK Assistant thread
Provide type='agent' for the auto-created JEK Assistant thread (idempotent — returns the existing one), user_id for a 1:1 DM with a JEK user, phone for a DM by phone number (creates the counterparty stub if needed), or type='group' with member_ids for a new group chat. JEK (docs/71 C1a): a DM to someone who has not saved you as a contact (and has no accepted DM with you) starts as a MESSAGE REQUEST (`request_status: requested`) the recipient accepts or declines with PATCH /api/v1/me/messaging/conversations/{id}; a blocked pair is refused (403 CANNOT_MESSAGE). Groups can only include people you can already chat with.
Auth
user_bearer
Parameters
  • type (body, "dm" | "group" | "agent")
  • user_id (body, uuid)
  • phone (body, string (E.164))
  • title (body, string)
  • member_ids (body, uuid[])
GET/api/v1/me/messaging/conversations/{id}JEKStable
https://api.jek.app
Fetch conversation detail + message page
Returns the conversation, its members, and the most recent `limit` messages (default 50). Pass `before` (ISO timestamp) for pagination to older messages.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • limit (query, integer (default 50, max 200))
  • before (query, ISO-8601 timestamp)
PATCH/api/v1/me/messaging/conversations/{id}JEKStable
https://api.jek.app
Mark read, or answer a message request
No body (or `{}`): marks the conversation read. `{request: "accept" | "decline"}` (docs/71 C1a): the RECIPIENT of a message request answers it → `{ok, request_status}`. Until accepted, the requester may send one text message only (403 REQUEST_PENDING); a declined request refuses further messages (403 REQUEST_DECLINED).
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • request (body, "accept" | "decline")
POST/api/v1/me/messaging/conversations/{id}/messagesJEKStable
https://api.jek.app
Send a message (text, image, file, voice)
Set kind='text' (default) for plain text. For attachments upload via POST /api/v1/me/messaging/attachments first, then send kind='image'|'file'|'voice' with the returned path in attachments. Mentioning @jek in a non-agent conversation triggers a JEK Assistant reply from the fan-out job. JEK gifts (docs/71 C2): kind='voucher' with `metadata.coupon_code` (or the app's `attachments[0].code`) shares a code — nothing moves, the server snapshots it into `metadata.voucher` (`unverified:true` when unknown); with `metadata.user_voucher_id` it TRANSFERS an owned voucher to the other person. kind='kash' with `metadata.kash.amount` or `attachments[0].amount` (HK$, optional `metadata.request_id`) gifts JEK Kash, written back into both. Value gifts need an accepted one-to-one chat: 403 GIFT_NEEDS_ACCEPTED_CHAT / NOT_YOUR_VOUCHER / KASH_OFF, 409 VOUCHER_NOT_TRANSFERABLE / KASH_INSUFFICIENT / KASH_GIFT_LIMIT. End-to-end encrypted chats (docs/71 C1b, the conversation's `e2e: true`): text and media are refused here (400 E2E_REQUIRED) — send them encrypted with POST …/e2e-messages; voucher, kash and trip still go through this route.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • body (body, string (max 4000), required)
  • kind (body, "text" | "image" | "file" | "voice" | "video" | "location" | "contact" | "voucher" | "kash" | "trip")
  • reply_to_id (body, uuid)
  • attachments (body, Array<{ bucket: string; path: string; name?: string; mime?: string; size?: number }>)
  • metadata (body, object)
POST/api/v1/me/messaging/conversations/{id}/typingJEKStable
https://api.jek.app
Broadcast a typing indicator (3s TTL)
Fires a lightweight realtime event other members receive within ~200ms. Client should debounce — call at most once every 3 seconds while the user is actively typing.
Auth
user_bearer
POST/api/v1/me/messaging/attachmentsJEKStable
https://api.jek.app
Request a signed upload URL for a chat attachment
Returns a one-shot signed URL you can PUT the raw file to directly (never rehashed through the Worker). Returns the storage path to include in the subsequent POST /messages call. Bucket is private — read access is signed on demand via GET /attachments?path=...
Auth
user_bearer
Parameters
  • conversation_id (body, uuid, required)
  • filename (body, string, required)
GET/api/v1/me/messaging/attachmentsJEKStable
https://api.jek.app
Sign a read URL for an existing attachment path
Auth
user_bearer
Parameters
  • path (query, string, required)
GET/api/v1/me/messaging/candidatesJEKStable
https://api.jek.app
List uploaded contacts who are already on JEK
Cross-references the caller's uploaded contacts with jek_account_users to power the New Chat picker. Returns [{ user_id, name, phone }].
Auth
user_bearer
GET/api/v1/me/messaging/blocksJEKStable
https://api.jek.app
People you've blocked in chat
Per app. `{data:[{user_id, created_at}]}`.
Auth
user_bearer
POST/api/v1/me/messaging/blocksJEKStable
https://api.jek.app
Block someone in chat
Body `{user_id}`. Stops new threads and messages both ways; the other person is told only "You can't message this person" (403 CANNOT_MESSAGE).
Auth
user_bearer
Parameters
  • user_id (body, string, required)
DELETE/api/v1/me/messaging/blocksJEKStable
https://api.jek.app
Unblock someone
Body `{user_id}`.
Auth
user_bearer
Parameters
  • user_id (body, string, required)
POST/api/v1/me/messaging/reportsJEKStable
https://api.jek.app
Report a conversation
Body `{conversation_id, reason: spam|harassment|scam|inappropriate|other, message_ids?, reported_user_id?, note?, forwarded?}`. The caller must be a member of the thread in this app. End-to-end encrypted chats (docs/76): `forwarded: [{message_id, plaintext, franking_key}]` (≤20) is what the reporter decrypted; it is stored only if every item passes the franking check (the key opens the sender's commitment, and the server's tag binds it to this chat, sender and time), otherwise 400 FORWARD_NOT_VERIFIED and nothing is stored. With no `reported_user_id`, forwards from one person report that person. `reported_user_id`, when given: with forwards it must be one of the verified senders (400 REPORTED_USER_MISMATCH); without, it must be a current or past member of the thread (400 REPORTED_USER_NOT_IN_CHAT); never the reporter (400 REPORTED_USER_SELF). Forwarded ids are kept first within the 50 message ids stored.
Auth
user_bearer
Parameters
  • conversation_id (body, string, required)
  • reason (body, string, required)
  • message_ids (body, array)
  • reported_user_id (body, string)
  • note (body, string)
  • forwarded (body, Array<{ message_id: uuid; plaintext: string; franking_key: base64 }>)
Push
GET/api/public/v1/push-configJEKStable
https://api.jek.app
VAPID public key + service worker path (public)
Browsers call this to obtain the VAPID applicationServerKey before subscribing to Web Push. Also returns the service worker path (/sw.js).
Auth
no auth
POST/api/v1/me/push-tokensJEKStable
https://api.jek.app
Register a Web Push subscription or Expo push token
For web, pass { platform: 'web', endpoint, p256dh, auth } from PushSubscription.toJSON(). For native, pass { platform: 'ios' | 'android', expo_token } from expo-notifications' getExpoPushTokenAsync(). Upsert is de-duped by endpoint / expo_token so it's safe to call on every app start.
Auth
user_bearer
Parameters
  • platform (body, "web" | "ios" | "android")
  • endpoint (body, string (web only))
  • p256dh (body, string (web only))
  • auth (body, string (web only))
  • expo_token (body, string (native only))
DELETE/api/v1/me/push-tokensJEKStable
https://api.jek.app
Unregister a push token (on sign-out or permission revoke)
Auth
user_bearer
Parameters
  • endpoint (query, string)
  • expo_token (query, string)
JEK Receipts
POST/api/helper/generate-pdfJEKStable
https://api.jek.app
Generate a JEK PDF for the caller's Wonder ride
Accepts { order_id, locale? }. Requires a JEK bearer, JEK scope, X-JEK-Env and the caller's reconciled Wonder customer session. Reads the order server-side, renders in JEK and returns { url, expiresIn: 600 } from private jek-receipts storage. Caller-supplied fileData, template, folder and financial figures are refused.
Auth
user_bearer
Saved Places
GET/api/v1/me/saved-placesJEKStable
https://api.jek.app
List the caller's saved places
Home, Work and custom places, in the rider's display order. `meta.max_places` is the ceiling. Each place carries the normalized `{ placeId, text, fullText, lat, lng, provider }` that /api/v1/geo/place answers with, so it can be booked without a second resolve.
Auth
user_bearer
POST/api/v1/me/saved-placesJEKStable
https://api.jek.app
Save a Home, Work or custom place
The place is resolved and normalized server-side from `placeId` (or accepted as a dropped pin when `place` carries lat, lng and a name); raw display text alone is refused with 400 `invalid_place`, and an id the provider cannot resolve with 422 `unresolvable_place`. One Home and one Work per rider: a second is 409 `home_already_exists` / `work_already_exists`. `pickup_note` is private until the rider books from this place.
Auth
user_bearer
Parameters
  • type (body, "home" | "work" | "custom")
  • label (body, string)
  • placeId (body, string)
  • place (body, object)
  • pickup_note (body, string)
GET/api/v1/me/saved-places/{id}JEKStable
https://api.jek.app
Read one saved place
Auth
user_bearer
Parameters
  • id (path, uuid, required)
PATCH/api/v1/me/saved-places/{id}JEKStable
https://api.jek.app
Edit a saved place
Edit label, pickup_note (null clears), type, sort_order or the place itself (placeId / place). Send the `version` you last read: a stale one is 409 `version_conflict` and nothing is written. The response carries the new version.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • version (body, integer)
  • label (body, string)
  • pickup_note (body, string | null)
  • type (body, "home" | "work" | "custom")
  • placeId (body, string)
DELETE/api/v1/me/saved-places/{id}JEKStable
https://api.jek.app
Delete a saved place
Soft delete, idempotent: a repeated delete answers the same `{ data: { id, deleted: true } }`. The place leaves future recommendations; historical trips are untouched.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/saved-places/reorderJEKStable
https://api.jek.app
Persist the display order
Body `{ ids: [...] }` in the order to show. Places left out keep their relative order after the named ones. Answers the full list.
Auth
user_bearer
Parameters
  • ids (body, uuid[], required)
Emergency Contacts
GET/api/v1/me/emergency-contactsJEKStable
https://api.jek.app
List the caller's emergency contacts
`meta` carries `max_contacts` (configurable, default 5), `supported_channels` (today `sms`) and `verification_delivery`: `simulated` on the staging fulfilment env (X-JEK-Env: staging; no message is sent and the platform's fixed test code confirms) or `unavailable` where no SMS provider exists yet.
Auth
user_bearer
POST/api/v1/me/emergency-contactsJEKStable
https://api.jek.app
Add an emergency contact
The phone is normalized to E.164 (a bare local number is read as +852; send `default_country` to change that). Refused: an invalid number (400 `invalid_phone`), the rider's own number (400 `invalid_phone`), a number already saved (409 `duplicate_contact`), and one past the ceiling (409 `contact_limit_reached`). New contacts are `pending` until verified; nothing automated reaches them before that.
Auth
user_bearer
Parameters
  • name (body, string, required)
  • phone (body, string, required)
  • relationship (body, "family" | "friend" | "partner" | "colleague" | "other")
  • notification_channels (body, string[])
  • share_trip_by_default (body, boolean)
GET/api/v1/me/emergency-contacts/{id}JEKStable
https://api.jek.app
Read one emergency contact
Auth
user_bearer
Parameters
  • id (path, uuid, required)
PATCH/api/v1/me/emergency-contacts/{id}JEKStable
https://api.jek.app
Edit contact details or preferences
Conditional on `version` (409 `version_conflict` when stale). Changing `phone` resets `verification_status` to `pending` — the consent belonged to the old number.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • version (body, integer)
  • name (body, string)
  • phone (body, string)
  • relationship (body, string)
  • notification_channels (body, string[])
  • share_trip_by_default (body, boolean)
DELETE/api/v1/me/emergency-contacts/{id}JEKStable
https://api.jek.app
Delete an emergency contact
Soft delete, idempotent. The contact stops receiving anything immediately; if it was the primary, nobody is promoted in its place.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/emergency-contacts/{id}/verificationJEKStable
https://api.jek.app
Send the verification / consent challenge
Issues a 6-digit code valid for 10 minutes, at most once a minute per contact (429 `rate_limited`). 409 `already_verified` for a verified contact. 503 `notification_provider_unavailable` where no delivery exists (alpha/production today); on staging the send is simulated and `meta.delivery` says so.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/emergency-contacts/{id}/verification/confirmJEKStable
https://api.jek.app
Confirm the verification code
200 with `meta.outcome` verified; 400 `invalid_code` (with `attempts_remaining`, 5 per code); 409 `verification_not_started`; 410 `verification_expired` when the code lapsed or the attempts ran out.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • code (body, string, required)
POST/api/v1/me/emergency-contacts/{id}/set-primaryJEKStable
https://api.jek.app
Make this the primary contact
Zero or one primary per rider; the previous primary steps down. Idempotent.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
Profile
GET/api/v1/me/profile-imageJEKStable
https://api.jek.app
The caller's profile image
`data.profile_image` is null when the caller has none in this app. The `url` is a signed, short-lived link into a private bucket — render it, do not store it; `expires_in` is its life in seconds, and re-reading this endpoint (or GET /api/v1/me, which carries the same object) mints a fresh one.
Auth
user_bearer
POST/api/v1/me/profile-imageJEKStable
https://api.jek.app
Upload a profile image, or replace the current one
Send `{ image }` as a data URL or bare base64, or a multipart body with an `image` part — the same pair the licence scan takes, so a client already doing one needs nothing new. This is BOTH the upload and the edit: there is one current image per rider per app, so a second POST replaces the first and the old object is deleted. 201 when the rider had none, 200 when one was replaced (`data.replaced` says the same thing). The format is read off the bytes, never off the declared content type: JPEG, PNG and WebP are stored, and HEIC — what an iPhone hands over by default — is refused 415 `image_format_unsupported` with `detected` and `accepted`, because nothing but iOS can display it and this server has no way to transcode. Over 5 MB decoded is 413 `image_too_large` carrying `max_bytes`; bytes that are not an image at all are 400 `invalid_image`; no image in the body is 400 `image_required`.
Auth
user_bearer
Parameters
  • image (body, string | file, required)
DELETE/api/v1/me/profile-imageJEKStable
https://api.jek.app
Remove the current profile image
The row and the stored object both go. Idempotent: a rider with no image answers 200 with `removed: false` rather than 404, so a retry over a flaky connection never has to tell the two apart. Only this app's image is removed — the same account's picture in the other app is untouched.
Auth
user_bearer
GET/api/v1/me/account/deletionJEKStable
https://api.jek.app
The caller's pending account deletion
`{status:"none"}`, or `{status:"scheduled", requested_at, scheduled_for}` for this app (`x-user-scope`). A deletion runs 30 days after it is confirmed; until then signing in cancels it (the sign-in response then carries `account_deletion_cancelled: true`). On `scheduled_for` the app's personal data — saved places, safety contacts, synced contacts, push tokens, referral code, profile image, saved cards — is removed; rides, payments and receipts are kept for accounting. When no other app remains on the identity, its name and phone are wiped and the number can sign up again as a new account.
Auth
user_bearer
DELETE/api/v1/me/account/deletionJEKStable
https://api.jek.app
Cancel a pending account deletion
Cancels this app's pending request. Idempotent: nothing pending answers 200 `{status:"none"}`, not 404.
Auth
user_bearer
JEK AI (MCP)
POST/mcpJEKStable
https://api.jek.app
The JEK MCP server (streamable HTTP)
An MCP server acting as ONE signed-in JEK passenger (docs/73). JSON-RPC over POST, stateless, JSON responses: `initialize`, `tools/list`, `tools/call`. Bearer = an access token from POST /oauth/token. Without a valid token: 401 with `WWW-Authenticate: Bearer resource_metadata="https://api.jek.app/.well-known/oauth-protected-resource"`, which is how a client discovers the sign-in. 17 tools — read: ride_quote, list_rides, ride_status, kash_balance, list_vouchers, find_places, place_details, list_conversations; hand-off (nothing booked or paid): prepare_booking, prepare_tip; pending (confirm_action): send_message, share_trip, cancel_ride; app-only confirmation: send_kash, gift_voucher; confirm_action, cancel_action. GET (a server-notification stream this server never uses) and DELETE (a no-op session end) are answered for protocol compatibility only.
Auth
user_bearer
GET/.well-known/oauth-protected-resourceJEKStable
https://api.jek.app
MCP resource metadata (RFC 9728)
`{resource: "https://api.jek.app/mcp", authorization_servers, scopes_supported: ["jek"], bearer_methods_supported}`. Also served at `/.well-known/oauth-protected-resource/mcp`.
Auth
no auth
GET/.well-known/oauth-protected-resource/mcpJEKStable
https://api.jek.app
MCP resource metadata, path-suffixed form
The same document as /.well-known/oauth-protected-resource, at the location MCP clients try first for /mcp.
Auth
no auth
GET/.well-known/oauth-authorization-serverJEKStable
https://api.jek.app
OAuth server metadata (RFC 8414)
Endpoints for MCP sign-in: authorization_endpoint `/oauth/authorize` (a page: JEK phone + SMS code, then consent; existing JEK accounts only), token_endpoint, registration_endpoint, revocation_endpoint. PKCE S256 only; public clients only (`token_endpoint_auth_method: none`).
Auth
no auth
POST/oauth/registerJEKStable
https://api.jek.app
Register an MCP client (RFC 7591)
`{client_name?, redirect_uris: [...]}` → 201 `{client_id, client_name, redirect_uris, token_endpoint_auth_method: "none", grant_types, response_types}`. Redirect URIs: https, or http on localhost / 127.0.0.1 / [::1]; no fragment; 1–5 of them. No secret is issued. Rate-limited per IP (429 slow_down).
Auth
no auth
Parameters
  • redirect_uris (body, string[], required)
  • client_name (body, string)
POST/oauth/tokenJEKStable
https://api.jek.app
Trade a code or refresh token for an MCP access token
Form-encoded (or JSON). `grant_type=authorization_code` with `code`, `client_id`, `redirect_uri`, `code_verifier` (PKCE S256); the code is single-use and lives 60 s. `grant_type=refresh_token` with `refresh_token`, `client_id`; refresh tokens rotate on every use and a replayed one revokes the whole sign-in. Answers `{access_token (1 h), token_type: "Bearer", expires_in, refresh_token (30 d), scope: "jek"}`. Errors per RFC 6749: 400 invalid_grant / invalid_request / unsupported_grant_type.
Auth
no auth
Parameters
  • grant_type (body, "authorization_code" | "refresh_token", required)
POST/oauth/revokeJEKStable
https://api.jek.app
Revoke an MCP sign-in (RFC 7009)
`token=<access or refresh token>`. Ends every token of that sign-in. Always 200, known token or not.
Auth
no auth
Parameters
  • token (body, string, required)
GET/api/oauth/appJEKStable
https://api.jek.app
Which app is asking to connect
For the /oauth/authorize page. `?client_id&redirect_uri` → `{client_id, client_name}`; 400 BAD_CLIENT / BAD_REDIRECT when the app is unknown or did not register that redirect. The OAuth endpoints themselves (/.well-known/*, /oauth/register, /oauth/token, /oauth/revoke) are described in docs/73.
Auth
no auth
Parameters
  • client_id (query, string, required)
  • redirect_uri (query, string, required)
POST/api/oauth/approveJEKStable
https://api.jek.app
Let an MCP app act for you
Called by /oauth/authorize with the fresh JEK session. `{client_id, redirect_uri, code_challenge, code_challenge_method:'S256', state?}` → `{redirect_to}` carrying a single-use, 60-second `code`. JEK passengers only (403 NOT_JEK_USER); 400 BAD_PKCE / BAD_CLIENT / BAD_REDIRECT.
Auth
user_bearer
GET/api/v1/me/ai/connectionsJEKStable
https://api.jek.app
Apps connected to your JEK account
JEK only. `{data:[{grant_id, client_id, client_name, connected_at, last_used_at}]}`, one per live sign-in.
Auth
user_bearer
DELETE/api/v1/me/ai/connections/{id}JEKStable
https://api.jek.app
Disconnect an app
JEK only. `{id}` = grant_id. Its tokens stop working at once. 404 when the connection is not yours.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/ai/actionsJEKStable
https://api.jek.app
What JEK AI prepared for you
JEK only. `?status=pending|confirmed|executed|failed|expired|cancelled`. `{data:[{id, tool, kind: pending|handoff, summary, confirm_via: client|app|null, status, expires_at, args, result, app_url}]}`, newest first (≤50). A pending action past `expires_at` reads as expired. Kash and voucher gifts (`confirm_via: app`) run only when confirmed here in the app.
Auth
user_bearer
Parameters
  • status (query, string)
GET/api/v1/me/ai/actions/{id}JEKStable
https://api.jek.app
One AI action or draft
JEK only. What the app opens for `jek://ai/draft/{id}`. A `book_ride` hand-off carries `args.route`, `args.quote` (with `quote_ref`) and the choices (classes, coupon / `user_voucher_id`, `kash_amount`, `scheduled_at`) to prefill booking; the app books through `POST /api/v1/me/rides` as usual.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/ai/actions/{id}/confirmJEKStable
https://api.jek.app
Confirm an AI action in the app
JEK only. Runs a pending action once (message, trip share, free cancel, Kash gift, voucher gift) through the same code the REST routes use, and answers the action with `status: executed|failed` and `result`. For a hand-off (booking, tip, paid cancel) it only marks the draft done — call it after the app has booked or paid. 404 NOT_FOUND, 409 NOT_PENDING / EXPIRED.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/ai/actions/{id}/cancelJEKStable
https://api.jek.app
Decline an AI action
JEK only. Drops a pending action or draft. 409 NOT_PENDING when it already ran or ended.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/ai/chatJEKStable
https://api.jek.app
Talk to JEK AI in the app
JEK only. `{messages:[{role:'user'|'assistant', content}], lang?, context?:{hasActiveTrip?}}` — the last 20 turns, the last one the passenger's. Answers the app's `AiChatResponse` `{reply, intent?, pending_action?, conversation_id}`. `intent {type: newTrip|updatePickup|updateDropoff, pickupQuery?, dropoffQuery?}` hands a booking to the app's booking screen. `pending_action {action_id, summary, status: needs_confirmation|needs_app_confirmation|handoff, expires_at}` is confirmed with `POST /api/v1/me/ai/actions/{id}/confirm`. The model reads rides, Kash, vouchers, chats and Explore through the same tools as /mcp. Refusals carry a showable `reply`: 429 AI_DAILY_LIMIT (per passenger per Hong Kong day) / AI_BUSY, 402 AI_CREDITS, 503 AI_OFF / AI_UNAVAILABLE.
Auth
user_bearer
Parameters
  • messages (body, Array<{role, content}>, required)
  • lang (body, string)
  • context (body, {hasActiveTrip?: boolean})
Merchant
POST/api/v1/merchant/vouchers/redeemJEKStable
https://api.jek.app
Mark a customer's voucher used at the counter
`{redeem_code}` (8 characters). Only this merchant's (or its chain's) vouchers; any other code reads 404. Used once: 409 USED with `used_at` on a second scan.
Auth
user_bearer
Parameters
  • redeem_code (body, string, required)
Encrypted chat
POST/api/v1/me/messaging/conversations/{id}/e2e-messagesJEKStable
https://api.jek.app
Send an end-to-end encrypted message
JEK app only; header `x-e2e-device-secret` of the sending device. Body `{sender_device_id, envelopes: [{recipient_device_id, type: prekey|message|sender_key_distribution, ciphertext (base64, ≤64 KiB)}], franking_commitment (32-byte base64 HMAC-SHA256), client_id?}`. The envelopes must cover EXACTLY every active device of every member except the sending one (your own other devices included); otherwise 409 DEVICES_CHANGED `{missing, extra, devices}` — refresh those bundles, re-encrypt, resend. 409 NO_RECIPIENT_DEVICES `{users}` when a member has no device at all. Writes one message (kind `e2e`, body null, `metadata.franking`) and one envelope per device; 201 `{message, envelopes, replayed}`. A repeated client_id returns the first message (200, `replayed: true`), enforced by a unique index so concurrent retries also get one message. The message and its envelopes are written in one transaction, so a replay always points at a delivered message; 409 RETRY only before migration 20261002120000 (the first attempt failed while the retry waited) — send again. 409 NOT_E2E when the chat is not encrypted; 403 DEVICE_NOT_AUTHORIZED; 503 E2E_UNAVAILABLE until migrated and CHAT_FRANKING_SECRET is set.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • sender_device_id (body, uuid, required)
  • envelopes (body, Array<{ recipient_device_id: uuid; type: string; ciphertext: base64 }>, required)
  • franking_commitment (body, base64 (32 bytes), required)
  • client_id (body, string)
GET/api/v1/me/e2e/devicesJEKStable
https://api.jek.app
My encrypted-chat devices
The caller's active devices: `{id, device_no, name, platform, is_primary, linked_by_device, registration_id, identity_key, signed_prekey, created_at, last_seen_at}`. Public keys only. JEK app only.
Auth
user_bearer
POST/api/v1/me/e2e/devicesJEKStable
https://api.jek.app
Register the account's first device (the phone)
Body `{platform: ios|android|web, registration_id (1-16380), identity_key, signed_prekey: {key_id, public_key, signature}, prekeys?: [{key_id, public_key}] (≤100), name?}`; keys are libsignal-serialised base64 (33-byte public keys, 64-byte signatures). → 201 `{device, device_secret, prekeys_remaining}`; `device_secret` is shown once and goes in `x-e2e-device-secret` on every device-scoped call. The first device is the primary; with one already registered, 409 LINK_REQUIRED `{recovery_available: true}` — link further devices by QR, or replace a lost phone through /api/v1/me/e2e/recovery/start. Registering can switch the caller's chats to encrypted (every member now has a device).
Auth
user_bearer
Parameters
  • platform (body, "ios" | "android" | "web", required)
  • registration_id (body, integer, required)
  • identity_key (body, base64, required)
  • signed_prekey (body, { key_id; public_key; signature }, required)
  • prekeys (body, Array<{ key_id; public_key }>)
  • name (body, string)
DELETE/api/v1/me/e2e/devices/{id}JEKStable
https://api.jek.app
Revoke a device
Revokes one of the caller's devices. A linked device needs only the session; the PRIMARY needs its own `x-e2e-device-secret` (403 DEVICE_NOT_AUTHORIZED otherwise) and takes every device on the account with it. Pre-keys and undelivered envelopes are deleted. → `{revoked: [ids]}`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/e2e/devices/{id}/prekeysJEKStable
https://api.jek.app
One-time pre-keys left
`{prekeys_remaining}` for the device; top up when it runs low. Header `x-e2e-device-secret`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/e2e/devices/{id}/prekeysJEKStable
https://api.jek.app
Upload pre-keys / rotate the signed pre-key
Body `{prekeys?: [{key_id, public_key}] (≤100 per call, ≤500 held), signed_prekey?: {key_id, public_key, signature}}`. Header `x-e2e-device-secret`. → `{prekeys_remaining}`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
GET/api/v1/me/e2e/devices/{id}/envelopesJEKStable
https://api.jek.app
Fetch this device's encrypted messages
Waiting envelopes, oldest first: `{envelopes: [{id, message_id, conversation_id, sender_user_id, sender_device_id, type, ciphertext, created_at}], more}`. `?limit` (≤200). No cursor: acknowledge what you stored, then fetch again while `more` (acknowledged envelopes are deleted). Header `x-e2e-device-secret`. Envelopes nobody fetches are deleted after 30 days.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • limit (query, integer)
POST/api/v1/me/e2e/devices/{id}/envelopes/ackJEKStable
https://api.jek.app
Acknowledge envelopes
`{ids: [...]}` (≤500) of envelopes this device has decrypted and stored; they are deleted at once. Header `x-e2e-device-secret`. → `{acked}`.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
  • ids (body, uuid[], required)
GET/api/v1/me/e2e/users/{userId}/bundlesJEKStable
https://api.jek.app
Key bundles to start sessions with someone
`{user_id, devices: [{device_id, device_no, registration_id, identity_key, signed_prekey, prekey}]}` for every active device of `userId` — someone the caller shares an accepted JEK dm or a group with, or the caller (for their own other devices). Each `prekey` is claimed for this caller only, and null once the device has run out. With only a PENDING message request between them, `prekey` is always null and nothing is claimed. 403 NOT_A_CONTACT for anyone else, a declined request or across a block; 429 SLOW_DOWN (60 a minute).
Auth
user_bearer
Parameters
  • userId (path, uuid, required)
POST/api/v1/me/e2e/link/startJEKStable
https://api.jek.app
Ask to link a new device (show a QR)
From the NEW device (web, tablet), signed in to the same account. Body: its public bundle, as for POST /api/v1/me/e2e/devices. → 201 `{id, code, device_secret, expires_at}` (5 minutes): show `code` as a QR, keep `device_secret`, poll GET /api/v1/me/e2e/link/{id}. 409 NO_PRIMARY_DEVICE until the phone is registered; 429 TOO_MANY_LINKS.
Auth
user_bearer
POST/api/v1/me/e2e/link/approveJEKStable
https://api.jek.app
Approve a scanned link code (phone)
From the PRIMARY device: `{code, device_id}` with the phone's `x-e2e-device-secret`. → 201 `{device}`. 403 NOT_PRIMARY / DEVICE_NOT_AUTHORIZED, 404 LINK_NOT_FOUND, 410 LINK_EXPIRED.
Auth
user_bearer
Parameters
  • code (body, string, required)
  • device_id (body, uuid, required)
POST/api/v1/me/e2e/link/rejectJEKStable
https://api.jek.app
Reject a scanned link code (phone)
From the PRIMARY device: `{code, device_id}` with the phone's `x-e2e-device-secret`. → `{status: "rejected"}`.
Auth
user_bearer
Parameters
  • code (body, string, required)
  • device_id (body, uuid, required)
GET/api/v1/me/e2e/link/{id}JEKStable
https://api.jek.app
Poll a link request (new device)
With the `x-e2e-device-secret` /link/start returned: `{id, status: pending|approved|rejected|expired, expires_at, device}`; `device` is set once approved, and the secret works from then on.
Auth
user_bearer
Parameters
  • id (path, uuid, required)
POST/api/v1/me/e2e/recovery/startJEKStable
https://api.jek.app
Lost phone: send the recovery SMS code
Step 1 of moving encrypted chat to a new phone. Sends a code to the number ON the account (SMS purpose `e2e_recovery`). Body `{deviceId?, lang?, captchaToken?}` → `{token, expires_in}`. 409 NOTHING_TO_RECOVER when the account has no device (register directly), 409 RECOVERY_PENDING when one is running, 429 SLOW_DOWN after 3 an hour. JEK app only.
Auth
user_bearer
Parameters
  • deviceId (body, string)
  • lang (body, string)
  • captchaToken (body, string)
POST/api/v1/me/e2e/recovery/confirmJEKStable
https://api.jek.app
Lost phone: spend the code, open the recovery
Body `{token, aut_code, deviceId?}` (deviceId as sent to /start). → 201 `{recovery: {id, status, requested_at, eligible_at, expires_at, stale_skip, decided_at}, recovery_secret}`; `recovery_secret` is shown once and goes in `x-e2e-recovery-secret` at /recovery/complete. `eligible_at` is 24 hours on — or now when every active device has been unseen for 30+ days (`stale_skip`). The old devices stay active meanwhile and any of them can cancel. Unless the wait was skipped, every device on the account gets a vague security push (data.type `e2e_security`: open the app and read GET /recovery), and one reminder about 6 hours before eligible_at; completion pushes once more. 401 AUTH_FAILED (wrong code, nothing spent), 401 FLOW_ALREADY_USED (replayed), 409 RECOVERY_PENDING, 429 SLOW_DOWN after 5 an hour.
Auth
user_bearer
Parameters
  • token (body, string, required)
  • aut_code (body, string, required)
  • deviceId (body, string)
GET/api/v1/me/e2e/recoveryJEKStable
https://api.jek.app
Lost phone: the latest recovery
`{recovery}` (the latest, any status: pending|cancelled|completed|expired) or `{recovery: null}`. The old phone checks it on open and offers to cancel a pending one; the new phone reads `eligible_at`.
Auth
user_bearer
DELETE/api/v1/me/e2e/recoveryJEKStable
https://api.jek.app
Lost phone: cancel a recovery (from an old device)
Needs `x-e2e-device-secret` of ANY of the account's active devices; the session alone is 403 DEVICE_NOT_AUTHORIZED. → `{status: "cancelled", recovery}`, or `{status: "none"}` when nothing is pending.
Auth
user_bearer
POST/api/v1/me/e2e/recovery/completeJEKStable
https://api.jek.app
Lost phone: register the new phone
From the new phone once `eligible_at` has passed, with header `x-e2e-recovery-secret` (the `recovery_secret` /recovery/confirm returned; 403 RECOVERY_NOT_AUTHORIZED without it — the session alone cannot finish). Body: its public bundle, as for POST /api/v1/me/e2e/devices. Revokes every old device (their pre-keys and undelivered envelopes go with them), registers this one as the primary, and posts a "security code changed" system notice (metadata `e2e_identity_changed`) in each of the caller's encrypted chats, broadcast with an `e2e_devices` event. → 201 `{device, device_secret, prekeys_remaining, revoked, notified_conversations, recovery}`; `device_secret` is shown once. 409 RECOVERY_WAITING `{eligible_at}`, 404 NO_RECOVERY, 410 RECOVERY_EXPIRED (7 days after eligible).
Auth
user_bearer
Parameters
  • platform (body, "ios" | "android" | "web", required)
  • registration_id (body, integer, required)
  • identity_key (body, base64, required)
  • signed_prekey (body, { key_id; public_key; signature }, required)
  • prekeys (body, Array<{ key_id; public_key }>)
  • name (body, string)
Supply platform
POST/api/v1/supplier/quotesJEKStable
https://api.jek.app
Fare quotes for a demand platform
The quote counterpart to POST /api/v1/supplier/orders. Authenticates with the shared X-Internal-Token (a partner is a platform, not a signed-in rider) and answers in the caller's registered dialect — Wonder callers get {code,message,data:{quotes,batch_id}}, native callers get {data:{quotes,batch_id}}. Priced from the same rate card the booking uses; batch_id ties a later booking back to the fares it was offered. Quotes are honoured for 10 minutes. Distance/duration echo what the caller sent — this path does not geocode or route. The classes offered are the globally enabled ones NARROWED by this partner's allow list at /admin/ride/partners: a partner with no list is offered everything, one that is not sold a named class is answered unknown_class, and a list that leaves nothing answers 403 no_partner_classes (not 503 no_card, which means the rate card itself is empty).
Auth
no auth
Parameters
  • x-internal-token (header, string, required)
  • vehicle_type_codes (body, string[], required)
  • from (body, object, required)
  • to (body, object, required)
  • distance_km (body, number)
Rides
GET/api/v1/me/ridesJEKStable
https://api.jek.app
List the caller's rides (account surface)
Rides and wishes together, newest first. History is paged by an opaque keyset cursor: echo `next_cursor` back as `?cursor=` for the next page, and stop when it comes back null. `limit` defaults to 50 and caps at 100. `?active=1` answers only the orders still in flight and is deliberately NOT paged. A `cursor` this endpoint did not issue is refused with 400 `invalid_cursor` rather than silently restarting at the newest row.
Auth
user_bearer
Parameters
  • active (query, string)
  • limit (query, number)
  • cursor (query, string)
JEK Wallet (legacy Wonder)
POST/api/wonder/auth/meJEKStable
https://api.jek.app
Legacy JEK auth: POST /wonder/auth/me
Auth
user_bearer
POST/api/wonder/auth/otp/sendJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_ACCOUNT_SECURITY_RETIRED; use /api/v1/auth/otp/send
Deprecated · Wonder account OTP retired on 2026-10-16; JEK owns code issuance and verification.
Auth
user_bearer
POST/api/wonder/auth/otp/verifyJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_ACCOUNT_SECURITY_RETIRED; use /api/v1/auth/otp/verify
Deprecated · Wonder account OTP retired on 2026-10-16; JEK owns code issuance and verification.
Auth
user_bearer
POST/api/wonder/auth/pin/statusJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_ACCOUNT_SECURITY_RETIRED; use JEK password/OTP and device biometrics
Deprecated · JEK owns account authentication; Wonder account PIN and device binding retired on 2026-10-16.
Auth
user_bearer
POST/api/wonder/auth/pin/verify-oldJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_ACCOUNT_SECURITY_RETIRED; use JEK password/OTP and device biometrics
Deprecated · JEK owns account authentication; Wonder account PIN and device binding retired on 2026-10-16.
Auth
user_bearer
POST/api/wonder/auth/pin/set-newJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_ACCOUNT_SECURITY_RETIRED; use JEK password/OTP and device biometrics
Deprecated · JEK owns account authentication; Wonder account PIN and device binding retired on 2026-10-16.
Auth
user_bearer
POST/api/wonder/auth/pin/forgot-resetJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_ACCOUNT_SECURITY_RETIRED; use JEK password/OTP and device biometrics
Deprecated · JEK owns account authentication; Wonder account PIN and device binding retired on 2026-10-16.
Auth
user_bearer
GET/api/wonder/account/kyc-statusJEKStable
https://api.jek.app
Legacy JEK account: GET /wonder/account/kyc-status
Auth
user_bearer
POST/api/wonder/jumio/signup-tokenJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_KYC_PROXY_RETIRED
Deprecated · No current app/admin callers. JEK KYC uses /api/registry/jumio/signup, /status and /bind.
Auth
user_bearer
POST/api/wonder/jumio/signin-tokenJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_KYC_PROXY_RETIRED
Deprecated · No current app/admin callers. JEK KYC uses /api/registry/jumio/signup, /status and /bind.
Auth
user_bearer
POST/api/wonder/jumio/resultJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_KYC_PROXY_RETIRED
Deprecated · No current app/admin callers. JEK KYC uses /api/registry/jumio/signup, /status and /bind.
Auth
user_bearer
POST/api/wonder/jumio/bindJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_KYC_PROXY_RETIRED
Deprecated · No current app/admin callers. JEK KYC uses /api/registry/jumio/signup, /status and /bind.
Auth
user_bearer
POST/api/wonder/jumio/eventJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_KYC_PROXY_RETIRED
Deprecated · No current app/admin callers. JEK KYC uses /api/registry/jumio/signup, /status and /bind.
Auth
user_bearer
POST/api/wonder/taxi/universal-transactionsJEKDeprecated
https://api.jek.app
Retired Wonder ride transaction feed
Deprecated · Returns 410 WONDER_HISTORY_RETIRED. Use /api/v1/me/rides, /api/v1/me/activity and /api/v1/me/rides/{id}/related-activities with the JEK session and explicit X-JEK-Env.
Auth
user_bearer
POST/api/wonder/taxi/related-activitiesJEKDeprecated
https://api.jek.app
Retired Wonder ride related activities
Deprecated · Returns 410 WONDER_HISTORY_RETIRED. Use /api/v1/me/rides, /api/v1/me/activity and /api/v1/me/rides/{id}/related-activities with the JEK session and explicit X-JEK-Env.
Auth
user_bearer
GET/api/wonder/wallet/cardsJEKStable
https://api.jek.app
GET /wonder/wallet/cards Signed READ-ONLY card list.
Auth
user_bearer
POST/api/wonder/wallet/cards/addressJEKStable
https://api.jek.app
POST /wonder/wallet/cards/address Create a delivery address for the authenticated user's card.
Auth
user_bearer
PUT/api/wonder/wallet/cards/{cardId}/address/{addressId}JEKStable
https://api.jek.app
PUT /wonder/wallet/cards/:cardId/address/:addressId Update an existing delivery address for the authenticated user's card.
Auth
user_bearer
Parameters
  • cardId (path, string, required)
  • addressId (path, string, required)
GET/api/wonder/wallet/cards/terminate-reasonsJEKStable
https://api.jek.app
GET /wonder/wallet/cards/terminate-reasons READ-ONLY list of card termination reason options.
Auth
user_bearer
GET/api/wonder/wallet/cards/materialJEKStable
https://api.jek.app
GET /wonder/wallet/cards/material Signed READ-ONLY card material type list for physical card application.
Auth
user_bearer
GET/api/wonder/wallet/cards/fee-rules/{currency}JEKStable
https://api.jek.app
GET /wonder/wallet/cards/fee-rules/:currency Public READ-ONLY card fee rules for a currency.
Auth
user_bearer
Parameters
  • currency (path, string, required)
GET/api/wonder/wallet/cards/{cardId}JEKStable
https://api.jek.app
GET /wonder/wallet/cards/:cardId Signed READ-ONLY card detail.
Auth
user_bearer
Parameters
  • cardId (path, string, required)
GET/api/wonder/wallet/ledger-balanceJEKStable
https://api.jek.app
GET /wonder/wallet/ledger-balance Signed READ-ONLY ledger balance.
Auth
user_bearer
GET/api/wonder/wallet/fund-sourcesJEKStable
https://api.jek.app
GET /wonder/wallet/fund-sources Signed READ-ONLY fund sources.
Auth
user_bearer
PUT/api/wonder/wallet/fund-sources/sortJEKStable
https://api.jek.app
PUT /wonder/wallet/fund-sources/sort Mirrors Flutter wallet.api.dart userFundSourcesSort(): PUT /svc/ts/api/v2/b2c/user_fund_sources/sort Bo
Auth
user_bearer
GET/api/wonder/wallet/digital-wallet/currenciesJEKStable
https://api.jek.app
GET /wonder/wallet/digital-wallet/currencies Signed READ-ONLY list of supported digital wallet currencies (USDT etc).
Auth
user_bearer
GET/api/wonder/wallet/digital-wallet/networks/{currency}JEKStable
https://api.jek.app
GET /wonder/wallet/digital-wallet/networks/:currency Signed READ-ONLY list of blockchain networks for a digital currency.
Auth
user_bearer
Parameters
  • currency (path, string, required)
POST/api/wonder/wallet/digital-wallet/walletJEKStable
https://api.jek.app
POST /wonder/wallet/digital-wallet/wallet Signed READ-ONLY retrieval of the authenticated user's existing digital wallet address for a speci
Auth
user_bearer
GET/api/wonder/wallet/txn/listJEKStable
https://api.jek.app
Currency activity history via POST /svc/ts/api/v2/activities, scoped to the authenticated Kash account and billing currency.
Auth
user_bearer
GET/api/wonder/wallet/txn/card/{id}JEKStable
https://api.jek.app
GET /wonder/wallet/txn/card/:id Signed READ-ONLY card transaction detail.
Auth
user_bearer
Parameters
  • id (path, string, required)
GET/api/wonder/wallet/txn/payin/{id}JEKStable
https://api.jek.app
GET /wonder/wallet/txn/payin/:id Signed READ-ONLY payin (top-up) request detail.
Auth
user_bearer
Parameters
  • id (path, string, required)
GET/api/wonder/wallet/txn/payout/{id}JEKStable
https://api.jek.app
GET /wonder/wallet/txn/payout/:id Signed READ-ONLY payout (send) request detail.
Auth
user_bearer
Parameters
  • id (path, string, required)
GET/api/wonder/wallet/txn/fund-source/{id}JEKStable
https://api.jek.app
GET /wonder/wallet/txn/fund-source/:id Signed READ-ONLY fund-source transaction detail.
Auth
user_bearer
Parameters
  • id (path, string, required)
GET/api/wonder/wallet/txn/related/{type}/{id}JEKStable
https://api.jek.app
GET /wonder/wallet/txn/related/:type/:id Signed READ-ONLY related activities for a transaction.
Auth
user_bearer
Parameters
  • type (path, string, required)
  • id (path, string, required)
GET/api/wonder/wallet/rebate-schemesJEKStable
https://api.jek.app
Read Wonder's public rebate scheme catalog for the declared app environment.
Requires a JEK login and product membership. Returns {schemes, activeIds}. The server reads /svc/ts/public/api/v1/rebate_schemes without forwarding user or business credentials; card KYC, a reconciled holder and a business grant are not prerequisites for this metadata.
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
GET/api/wonder/wallet/cards/{cardId}/physical-deliverJEKStable
https://api.jek.app
GET /wonder/wallet/cards/:cardId/physical-deliver Signed READ-ONLY physical card delivery status for a given card.
Auth
user_bearer
Parameters
  • cardId (path, string, required)
GET/api/wonder/wallet/cards/{cardId}/verification-blacklistsJEKStable
https://api.jek.app
GET /wonder/wallet/cards/:cardId/verification-blacklists Signed READ-ONLY verification blacklist check for a card.
Auth
user_bearer
Parameters
  • cardId (path, string, required)
POST/api/wonder/wallet/cards/virtualJEKStable
https://api.jek.app
Create a virtual JEK Card on the selected network.
Body `{issuer_brand?: JCB|UnionPay, settlement_currency?: HKD|USD}`. The legacy `channel` field is also accepted; conflicting network fields are rejected and omitted networks remain JCB. Wonder GET /svc/ts/api/v2/card_issuers and the admin application/no-KYC gates determine availability. Creates through POST /svc/ts/api/v1/openapi/cards with card.issuer_brand; retains the existing identity, limits and single-live-card checks.
Auth
user_bearer
POST/api/wonder/wallet/emv-qrJEKDeprecated
https://api.jek.app
Retired: HTTP 410 QR_LEGACY_RETIRED
Deprecated · JCB has no QR payment feature. Use the direct /api/wonder/v1/qr/* proxy for UnionPay.
Auth
user_bearer
POST/api/wonder/wallet/check-atcJEKDeprecated
https://api.jek.app
Retired: HTTP 410 QR_LEGACY_RETIRED
Deprecated · JCB has no QR payment feature. Use the direct /api/wonder/v1/qr/* proxy for UnionPay.
Auth
user_bearer
GET/api/wonder/wallet/txn/card-by-auth/{authId}JEKStable
https://api.jek.app
GET /wonder/wallet/txn/card-by-auth/:authId Signed READ-ONLY card transaction lookup by Wonder auth_id.
Auth
user_bearer
Parameters
  • authId (path, string, required)
POST/api/wonder/wallet/cards/order/valuationJEKStable
https://api.jek.app
POST /wonder/wallet/cards/order/valuation Estimate the cost of a physical card order (material fee + promotions).
Auth
user_bearer
POST/api/wonder/wallet/cards/physicalJEKStable
https://api.jek.app
POST /wonder/wallet/cards/physical Create a physical card order (apply / replace / lost-reissue).
Auth
user_bearer
POST/api/wonder/wallet/cards/free-payJEKStable
https://api.jek.app
POST /wonder/wallet/cards/free-pay Zero-amount payment for a physical card order when the total is 0.
Auth
user_bearer
POST/api/wonder/wallet/cards/paid-payJEKStable
https://api.jek.app
POST /wonder/wallet/cards/paid-pay Vault-card SALE payment for a physical card order when the valuation total is greater than zero.
Auth
user_bearer
POST/api/wonder/wallet/cards/verification-tokenJEKStable
https://api.jek.app
POST /wonder/wallet/cards/verification-token Creates a Wonder verification token for a card-status write action (unlock, terminate).
Auth
user_bearer
POST/api/wonder/wallet/cards/spend-limit-otp/sendJEKStable
https://api.jek.app
POST /wonder/wallet/cards/spend-limit-otp/send Step 2 of the 5-step spend-limit OTP flow.
Auth
user_bearer
POST/api/wonder/wallet/cards/spend-limit-otp/verifyJEKStable
https://api.jek.app
POST /wonder/wallet/cards/spend-limit-otp/verify Step 4 of the 5-step spend-limit OTP flow.
Auth
user_bearer
PUT/api/wonder/wallet/cards/{cardId}/statusJEKStable
https://api.jek.app
PUT /wonder/wallet/cards/:cardId/status Changes a JEK card's status: "locked", "active" (unlock), or "terminated".
Auth
user_bearer
Parameters
  • cardId (path, string, required)
PUT/api/wonder/wallet/cards/{cardId}/editJEKStable
https://api.jek.app
PUT /wonder/wallet/cards/:cardId/edit Updates Transaction and Daily spend limits for a JEK card after OTP verification.
Auth
user_bearer
Parameters
  • cardId (path, string, required)
POST/api/wonder/wallet/cards/pci-card-revealJEKStable
https://api.jek.app
POST /wonder/wallet/cards/pci-card-reveal Reveals the full PAN, expiry, CVV, and cardholder name for a JEK Card using the Wonder PCI session
Auth
user_bearer
POST/api/wonder/wallet/cards/physical/not-receivedJEKStable
https://api.jek.app
POST /wonder/wallet/cards/physical/not-received Reports that a physical card has not been received.
Auth
user_bearer
POST/api/wonder/wallet/cards/physical/code-checkJEKStable
https://api.jek.app
POST /wonder/wallet/cards/physical/code-check Validates a physical card activation code before PIN setup.
Auth
user_bearer
POST/api/wonder/wallet/cards/pci-sessionJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_RAW_PCI_RETIRED
Deprecated · No current app/admin callers. Card reveal uses /api/wonder/wallet/cards/pci-card-reveal; provider PCI remains server-side.
Auth
user_bearer
POST/api/wonder/wallet/cards/pci-card-with-sessionJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_RAW_PCI_RETIRED
Deprecated · No current app/admin callers. Card reveal uses /api/wonder/wallet/cards/pci-card-reveal; provider PCI remains server-side.
Auth
user_bearer
POST/api/wonder/wallet/cards/pci-pin-with-sessionJEKStable
https://api.jek.app
POST /wonder/wallet/cards/pci-pin-with-session Sets a card PIN (new card activation or ATM PIN change).
Auth
user_bearer
POST/api/wonder/wallet/cards/pci-pin-verify-with-sessionJEKStable
https://api.jek.app
POST /wonder/wallet/cards/pci-pin-verify-with-session Verifies the current card PIN (ATM PIN change step 1).
Auth
user_bearer
GET/api/wonder/wallet/send/user-searchJEKStable
https://api.jek.app
GET /wonder/wallet/send/user-search Signed search for a transfer recipient by phone number, email, or display name.
Auth
user_bearer
POST/api/wonder/wallet/send/fee-lookupJEKStable
https://api.jek.app
POST /wonder/wallet/send/fee-lookup Calculates the transfer fee for a given currency + amount before the user commits.
Auth
user_bearer
POST/api/wonder/wallet/send/fx-quoteJEKStable
https://api.jek.app
POST /wonder/wallet/send/fx-quote Requests an FX quote for a cross-currency payout.
Auth
user_bearer
POST/api/wonder/wallet/send/otpJEKDeprecated
https://api.jek.app
Retired: HTTP 410 RAW_PAYOUT_OTP_RETIRED before provider/session dependencies
Deprecated · Raw payout OTP is retired; issuer authorization requires a provider-backed contract.
Auth
user_bearer
POST/api/wonder/wallet/send/payout/{requestId}/statusJEKStable
https://api.jek.app
POST /wonder/wallet/send/payout/:requestId/status Polls the status of a submitted payout request.
Auth
user_bearer
Parameters
  • requestId (path, string, required)
POST/api/wonder/wallet/digital-wallet/createJEKStable
https://api.jek.app
POST /wonder/wallet/digital-wallet/create Creates a new digital wallet address for the authenticated user for a given chain + asset.
Auth
user_bearer
POST/api/wonder/wallet/digital-wallet/check/{id}JEKStable
https://api.jek.app
POST /wonder/wallet/digital-wallet/check/:id Polls a pending digital wallet creation until it reaches "Active" status.
Auth
user_bearer
Parameters
  • id (path, string, required)
POST/api/wonder/statement/first-create-timeJEKStable
https://api.jek.app
POST /wonder/statement/first-create-time Fetches the date of the user's first Wonder card creation via a signed Taxi Gateway call.
Auth
user_bearer
POST/api/wonder/statement/previewJEKStable
https://api.jek.app
POST /wonder/statement/preview Starts async PDF generation for a calendar month via an UNSIGNED Galaxy Gateway call.
Auth
user_bearer
POST/api/wonder/statement/checkJEKStable
https://api.jek.app
POST /wonder/statement/check Polls the Galaxy Gateway for the status of an async PDF generation task.
Auth
user_bearer
GET/api/v1/me/wonder-linkJEKStable
https://api.jek.app
Fresh eKYC and Card/Kash recovery progress
JEK only; explicit x-jek-env. Owned fresh-policy KYC/status/identity_stored and reconciliation state/card_state/kash_state/error_code. Old approvals never count. New financial business, no document attributes or user tokens returned. docs/86.
Auth
user_bearer
POST/api/v1/me/wonder-linkJEKStable
https://api.jek.app
Recover your financial identity after fresh eKYC
Requires fresh current-policy Jumio approval and encrypted identity first. Leased job: canonical verified phone lookup, compare legacy document before immutable binding, or create a new user from verified extraction. Returns retry/action_required progress for provider/missing-contract failures. Reuses known owned cards; never creates a card or credits a balance. User sessions deferred. docs/86.
Auth
user_bearer
GET/api/wonder/wallet/payees/{id}/transactionsJEKStable
https://api.jek.app
The caller's wallet payouts to one payee
Separate wallet provider contract. Requires the JEK session and caller's reconciled wallet session. Requests only Payout rows and checks the returned payee id; does not supply ride or wish history.
Auth
user_bearer
Parameters
  • id (path, string, required)
  • offset (query, number)
  • limit (query, number)
GET/api/wonder/wallet/transactionsJEKDeprecated
https://api.jek.app
Retired shared Wonder transaction history
Deprecated · Returns 410 WONDER_HISTORY_RETIRED. Use /api/v1/me/rides, /api/v1/me/activity and /api/v1/me/rides/{id}/related-activities with the JEK session and explicit X-JEK-Env.
Auth
user_bearer
POST/api/wonder/wallet/cards/action-otp/sendJEKStable
https://api.jek.app
POST /wonder/wallet/cards/action-otp/send { action, verification_token } → POST /user/b2c/otp/send { action, phone, verification_token } → {
Auth
user_bearer
POST/api/wonder/wallet/cards/action-otp/verifyJEKStable
https://api.jek.app
POST /wonder/wallet/cards/action-otp/verify { action, aut_code, verification_token, token?
Auth
user_bearer
GET/api/wonder/wallet/payeesJEKStable
https://api.jek.app
GET /wonder/wallet/payees?offset&limit&phone&email → GET /svc/ts/api/v1/user/payees → { payees }
Auth
user_bearer
GET/api/wonder/wallet/payees/recentJEKStable
https://api.jek.app
GET /wonder/wallet/payees/recent → GET /svc/ts/api/v1/user/payees/recent → { payees }
Auth
user_bearer
GET/api/wonder/wallet/payees/{id}JEKStable
https://api.jek.app
GET /wonder/wallet/payees/:id → { payee }
Auth
user_bearer
Parameters
  • id (path, string, required)
PUT/api/wonder/wallet/payees/{id}JEKStable
https://api.jek.app
PUT /wonder/wallet/payees/:id { nickname } → PUT /svc/ts/api/v1/user/payees/{id} → { ok }
Auth
user_bearer
Parameters
  • id (path, string, required)
DELETE/api/wonder/wallet/payees/{id}JEKStable
https://api.jek.app
DELETE /wonder/wallet/payees/:id → DELETE /svc/ts/api/v1/user/payees/{id} → { ok }
Auth
user_bearer
Parameters
  • id (path, string, required)
POST/api/wonder/wallet/cards/order/promotion-checkJEKStable
https://api.jek.app
POST /wonder/wallet/cards/order/promotion-check { promotion_code } → { isAvailable }
Auth
user_bearer
GET/api/wonder/wallet/app-configJEKDeprecated
https://api.jek.app
Retired: returns HTTP 410 LEGACY_METADATA_RETIRED; current apps use bundled vehicle names and artwork
Deprecated · Wonder cloud config retired on 2026-10-16; current apps use bundled class names and artwork.
Auth
user_bearer
POST/api/wonder/wallet/taxi-orders/:id/receiptJEKStable
https://api.jek.app
Compatibility alias: JEK-generated PDF from the caller's verified Wonder order → { url, expiresIn }; no Wonder PDF helper
Auth
user_bearer
GET/api/wonder/wallet/taxi-evaluation-optionsJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_RIDE_PROXY_RETIRED
Deprecated · Legacy ride UI removed. Current ride links lead to JEK-owned history; the separate receipt alias remains supported.
Auth
user_bearer
POST/api/wonder/wallet/taxi-orders/:id/evaluationJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_RIDE_PROXY_RETIRED
Deprecated · Legacy ride UI removed. Current ride links lead to JEK-owned history; the separate receipt alias remains supported.
Auth
user_bearer
GET/api/wonder/wallet/txn/receive/:idJEKStable
https://api.jek.app
GET /wonder/wallet/txn/receive/:id → v1 digital_wallet transaction { txn } (legacy ReceiveDetail)
Auth
user_bearer
GET/api/wonder/wallet/txn/send/:idJEKStable
https://api.jek.app
GET /wonder/wallet/txn/send/:id → v1 payout_request { txn } (legacy SendDetail)
Auth
user_bearer
GET/api/wonder/wallet/taxi-orders/{id}/paymentJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_RIDE_PROXY_RETIRED
Deprecated · Legacy ride UI removed. Current ride links lead to JEK-owned history; the separate receipt alias remains supported.
Auth
user_bearer
POST/api/wonder/wallet/taxi-orders/{id}/paymentJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_RIDE_PROXY_RETIRED
Deprecated · Legacy ride UI removed. Current ride links lead to JEK-owned history; the separate receipt alias remains supported.
Auth
user_bearer
GET/api/wonder/wallet/taxi-orders/:idJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_RIDE_PROXY_RETIRED
Deprecated · Legacy ride UI removed. Current ride links lead to JEK-owned history; the separate receipt alias remains supported.
Auth
user_bearer
GET/api/wonder/wallet/advertiseJEKDeprecated
https://api.jek.app
Retired: returns HTTP 410 LEGACY_METADATA_RETIRED; link-card advertising removed
Deprecated · Wonder Payment registry advertising retired on 2026-10-16; the optional Link Card banner was removed.
Auth
user_bearer
PUT/api/wonder/wallet/fund-sources/ledger-currencyJEKStable
https://api.jek.app
PUT /wonder/wallet/fund-sources/ledger-currency { currency } → { fundingSources }
Auth
user_bearer
POST/api/wonder/auth/biologyJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_ACCOUNT_SECURITY_RETIRED; use JEK password/OTP and device biometrics
Deprecated · JEK owns account authentication; Wonder account PIN and device binding retired on 2026-10-16.
Auth
user_bearer
GET/api/wonder/auth/biologyJEKDeprecated
https://api.jek.app
Retired: HTTP 410 WONDER_ACCOUNT_SECURITY_RETIRED; use JEK password/OTP and device biometrics
Deprecated · JEK owns account authentication; Wonder account PIN and device binding retired on 2026-10-16.
Auth
user_bearer
GET/api/wonder/wallet/fund-sources/payment-methodsJEKStable
https://api.jek.app
GET /wonder/wallet/fund-sources/payment-methods → business Bearer + saved X-P-Business-ID → openapi/payment_methods reduced to brands both cit and mit allow → { paymentMethods }; provider diagnostics are surfaced
Auth
user_bearer
POST/api/wonder/wallet/fund-sources/cardsJEKStable
https://api.jek.app
POST /wonder/wallet/fund-sources/cards {} → business Bearer customer by JEK reference → hosted create-only wallet link; returns an encrypted verification handle; no PAN/CVV input
Auth
user_bearer
POST/api/wonder/wallet/fund-sources/cards/verifyJEKStable
https://api.jek.app
POST /wonder/wallet/fund-sources/cards/verify { verifyUuid } → owned new token check/readback and Treasury funding membership → { verified, state }; no customer session
Auth
user_bearer
POST/api/wonder/wallet/fund-sources/removeJEKStable
https://api.jek.app
POST /wonder/wallet/fund-sources/remove { id } → owned source token matched to JEK customer's vault → business Bearer DELETE /svc/payment/api/v1/openapi/customers/{uuid}/payment_tokens { token } → readback before { ok }
Auth
user_bearer
Wonder Treasury HCE and QR proxy
POST/api/wonder/v1/hce/issue_tokenJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/hce/issue_token. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/hce/change_token_stateJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/hce/change_token_state. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/hce/replenish_lukJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/hce/replenish_luk. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/hce/report_transactionJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/hce/report_transaction. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/hce/update_token_metadataJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/hce/update_token_metadata. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/hce/list_tokensJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/hce/list_tokens. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/qr/inquire_merchant_qrJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/qr/inquire_merchant_qr. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/qr/pay_merchant_qrJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/qr/pay_merchant_qr. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/qr/generate_consumer_qrJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/qr/generate_consumer_qr. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/qr/inquire_consumer_qr_cvmJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/qr/inquire_consumer_qr_cvm. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/qr/submit_consumer_qr_cvmJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/qr/submit_consumer_qr_cvm. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/qr/inquire_transactionJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/qr/inquire_transaction. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
POST/api/wonder/v1/qr/list_transactionsJEKStable
https://api.jek.app
Pass through to /svc/ts/api/v1/qr/list_transactions. Only top-level appUserId uses the authenticated account's bound Wonder ID. Other request bytes, response bodies and provider HTTP status are preserved. JEK session/environment authorization and server-held Wonder authentication apply.
Auth
user_bearer
Standard Ride compatibility
POST/api/v1/standard-rides/quotesJEKDeprecated
https://api.jek.app
Quote a Standard Ride
JEK bearer and the caller's Wonder session are required. JSON body: pickup, dropoff and optional stops; returns batchId, quotes and optional route.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/nearbyJEKDeprecated
https://api.jek.app
Find nearby taxis for a Standard Ride
JEK bearer and the caller's Wonder session are required. JSON body: lat, lng, radius?; returns env and taxis.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/pickup-serviceabilityJEKDeprecated
https://api.jek.app
Check Standard Ride pickup serviceability
JEK bearer and the caller's Wonder session are required. JSON body: lat and lng; returns whether this pickup can be quoted.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/ordersJEKDeprecated
https://api.jek.app
Book a quoted Standard Ride
JEK bearer and the caller's Wonder session are required. JSON body: batchId, selectedQuoteIds, accessPointId?; returns order.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/live-activity/tokenJEKDeprecated
https://api.jek.app
Bind a Standard Ride live-activity push token
JEK bearer and the caller's Wonder session are required. JSON body: orderId and pushToken; returns bound.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/order-listJEKDeprecated
https://api.jek.app
List the caller's Standard Rides
JEK bearer and the caller's Wonder session are required. JSON body: offset?, limit? and order filters; returns orders.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/order-detailJEKDeprecated
https://api.jek.app
Read a Standard Ride
JEK bearer and the caller's Wonder session are required. JSON body: orderId and liveDetail?; returns order.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/locations-quoteJEKDeprecated
https://api.jek.app
Quote a Standard Ride destination change
JEK bearer and the caller's Wonder session are required. JSON body: orderId, destination and additionalStops?; returns quote.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/locations-confirmJEKDeprecated
https://api.jek.app
Confirm a Standard Ride destination change
JEK bearer and the caller's Wonder session are required. JSON body: orderId and quoteId; returns status and optional quote.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/statusJEKDeprecated
https://api.jek.app
Read Standard Ride status
JEK bearer and the caller's Wonder session are required. JSON body: orderId; returns the current status.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/rideJEKDeprecated
https://api.jek.app
Read Standard Ride live driver information
JEK bearer and the caller's Wonder session are required. JSON body: orderId; returns the current ride.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/routerJEKDeprecated
https://api.jek.app
Read Standard Ride routing information
JEK bearer and the caller's Wonder session are required. JSON body: orderId; returns routing data.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/evaluation-optionsJEKDeprecated
https://api.jek.app
List Standard Ride evaluation options
JEK bearer and the caller's Wonder session are required. JSON body: Returns options.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/evaluateJEKDeprecated
https://api.jek.app
Evaluate a Standard Ride
JEK bearer and the caller's Wonder session are required. JSON body: orderId, stars, optionIds?, remark?, driverId?; returns ok.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/update-orderJEKDeprecated
https://api.jek.app
Update a Standard Ride's selected quotes
JEK bearer and the caller's Wonder session are required. JSON body: orderId, batchId and selectedQuoteIds; returns ok.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/v1/standard-rides/universal-transactionsJEKDeprecated
https://api.jek.app
Retired shared Wonder ride history
Returns 410 WONDER_HISTORY_RETIRED. Use owned JEK ride history and related activities with the JEK session and explicit X-JEK-Env. The bridge retirement policy marks this operation deprecated.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
POST/api/v1/standard-rides/related-activitiesJEKDeprecated
https://api.jek.app
Retired shared Wonder ride history
Returns 410 WONDER_HISTORY_RETIRED. Use owned JEK ride history and related activities with the JEK session and explicit X-JEK-Env. The bridge retirement policy marks this operation deprecated.
Deprecated · Bridge with no client: no caller in JEK Kash, Driver Pro, HK Taxi Go, the legacy Flutter app or api.jek.app itself. JEK Kash dropped it when the app cut over to the /api/v1/me/rides lane (4c71823c, 2026-08-27); only builds older than that call it
Auth
user_bearer
JEK Wallet
POST/api/wonder/wallet/address-autocompleteJEKStable
https://api.jek.app
Search delivery addresses
JSON { input, session_token, lat?, lng? }. Returns autocomplete suggestions for card delivery.
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/wonder/wallet/address-placeJEKStable
https://api.jek.app
Resolve a delivery address suggestion
JSON { place_id, session_token }. Returns the selected place.
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
GET/api/wonder/wallet/card-transactionsJEKStable
https://api.jek.app
List transactions for an owned card
Query card_id? (owned card selector), offset? (default 0) and limit? (1–100, default 50). Returns transactions with card, currency, amount, fee and merchant fields.
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
GET/api/wonder/wallet/digital-wallet/transactionsJEKStable
https://api.jek.app
List inbound deposits for an owned digital wallet
Query walletId (UUID), offset? (default 0), limit? (1–100, default 30), and optional startAt/endAt date range. Returns transactions and hasMore after verifying wallet ownership.
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/wonder/wallet/cards/physical/verification/startJEKStable
https://api.jek.app
Start identity verification for physical-card activation
JSON { referenceId }. Requires the caller's own live card. Returns sdkToken, dataCenter, expiresAt and a session-bound activation ticket.
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
POST/api/wonder/wallet/cards/physical/verification/confirmJEKStable
https://api.jek.app
Confirm identity verification for physical-card activation
JSON { referenceId, ticket }. Checks the authoritative owned workflow; returns an approved activation ticket only after approval. A completed SDK capture alone is insufficient.
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
JEK Card
GET/api/v1/me/card/3dsJEKStable
https://api.jek.app
List the caller's card purchase verifications or read one by ID
Requires JEK membership and an explicit supported card program. Returns only the caller's challenges. Responses are private and not cached.
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
  • id (query, string)
  • before (query, string)
POST/api/v1/me/card/3dsJEKStable
https://api.jek.app
Approve or reject an owned card purchase verification
Requires JEK membership and an explicit supported card program. JSON body contains only id and action; maximum body size is 1 KiB. Responses are private and not cached.
Auth
user_bearer
Parameters
  • X-JEK-Env (header, string, required)
  • id (body, string, required)
  • action (body, string, required)
Identity verification
POST/api/registry/jumio/signupJEKStable
https://api.jek.app
Create or resume the signed-in JEK account's Jumio SDK workflow
Requires JEK membership and x-jek-env (staging/alpha/production). Server-side Jumio OAuth credentials and workflow are configured at /admin/jumio. Creation is durably reserved and limited to five attempts per 24 hours; ambiguous creation does not re-POST. Returns data.workflow_id, account_id, sdk_token, data_center and expires_at; never OAuth credentials.
Auth
user_bearer
Parameters
  • x-jek-env (header, string, required)
  • request_id (body, uuid, required)
  • category_value (body, string)
  • country_value (body, string)
POST/api/registry/jumio/bindJEKStable
https://api.jek.app
Record submission or cancellation of an owned Jumio workflow
Requires JEK membership and x-jek-env. Takes workflow_id and outcome (submitted/cancelled). This does not approve verification. Cancellation checks Jumio retrieval before discarding an acquired workflow.
Auth
user_bearer
GET/api/registry/jumio/statusJEKStable
https://api.jek.app
Retrieve the caller's authoritative Jumio KYC status
Requires JEK membership and x-jek-env. Returns data.kyc_status, workflow_id and can_resume. Only overall PROCESSED/PASSED results grant approval; warnings remain pending review. Does not bind or issue a Wonder wallet/card.
Auth
user_bearer
Driver Assistant · Sign-in
POST/api/v1/da/auth/sessionJEKStable
https://api.jek.app
Sign in with a Wonder access token
Verifies the Wonder access token against that environment's user service, provisions the driver (profile, business id, fleet, payout account) and returns a Supabase session for the app. Allowlisted app-review accounts may send `phone` + `password` instead of a token.
Auth
no auth
Parameters
  • x-wonder-env (header, string)
  • wonder_access_token (body, string)
  • phone (body, string)
  • password (body, string)
  • device_id (body, string)
  • device_label (body, string)
DELETE/api/v1/da/auth/sessionJEKStable
https://api.jek.app
Sign out this device
Revokes the device's driver session, takes the driver off duty and retires their push tokens.
Auth
driver_bearer
Parameters
  • x-da-session (header, string)
GET/api/v1/da/auth/wonder-callbackJEKStable
https://api.jek.app
Browser bridge back into the app
Returns an HTML page, not JSON. Wonder's authorization screen redirects here with `code`; the page verifies the signed state and redirects to the app's deep link with the code appended. A missing or invalid state renders a "sign in again" page and never redirects.
Auth
no auth
Parameters
  • code (query, string, required)
  • s (query, string, required)
POST/api/v1/da/auth/wonder-oauth/codeJEKStable
https://api.jek.app
Start app-to-app Wonder sign-in
Mints a one-time Wonder authorization code and returns it with the app scheme and signed callback state. Returns 503 `WONDER_OAUTH_UNAVAILABLE` if Wonder refuses access to the code endpoint.
Auth
no auth
Parameters
  • x-wonder-env (header, string, required)
  • returnUrl (body, string)
GET/api/v1/da/auth/wonder-oauth/tokenJEKStable
https://api.jek.app
Exchange an app-to-app code for a Wonder token
Polls for a Wonder access token in the environment that issued the authorization code. `status` is `authorized`, `pending` (keep polling) or `rejected` (stop; `errorCode` is Wonder's, e.g. `EU200000` for an account not allowed to use Driver Assistant).
Auth
no auth
Parameters
  • x-wonder-env (header, string, required)
  • code (query, string, required)
  • native (query, string)
  • callback (query, string)
POST/api/v1/da/auth/wonder-qr/startJEKStable
https://api.jek.app
Create a Sign in with Wonder QR
Mints a Wonder login QR and returns its uuid and scannable URL. Poll `/wonder-qr/status` with the uuid until a token arrives.
Auth
no auth
Parameters
  • x-wonder-env (header, string, required)
GET/api/v1/da/auth/wonder-qr/statusJEKStable
https://api.jek.app
Poll a Wonder sign-in QR
Returns Wonder's scan flags for the QR and, once the driver confirms in the Wonder app, the access token to post to `POST /api/v1/da/auth/session`. `is_cancel` means mint a new QR.
Auth
no auth
Parameters
  • x-wonder-env (header, string, required)
  • id (query, string, required)
Driver Assistant · Chat
GET/api/v1/da/chat/configJEKStable
https://api.jek.app
Driver's Sendbird chat identity
Returns the Sendbird application id for the session's environment, the driver's Sendbird user id and nickname. No upstream call; 409 `WONDER_NOT_LINKED` when the session has no Wonder identity.
Auth
driver_bearer
GET/api/v1/da/chat/quick-repliesJEKStable
https://api.jek.app
Rider-chat quick-reply templates
Wonder's quick-reply templates, normalised to bilingual `en` / `zh` pairs and sorted by position.
Auth
driver_bearer
Driver Assistant · Fleet orders
GET/api/v1/da/fleet-ordersJEKStable
https://api.jek.app
List Fleet Mode Orders (查詢未登陸訂單)
One page of the orders Wonder flagged for manual settlement. Returns a bare array; a page shorter than `limit` is the last one.
Auth
driver_bearer
Parameters
  • limit (query, integer)
  • offset (query, integer)
  • state (query, string)
POST/api/v1/da/fleet-ordersJEKStable
https://api.jek.app
Claim a Fleet Mode Order
Submits a withdrawal request to Wonder for one order. The reference number is matched on the device; the call is not retried.
Auth
driver_bearer
Parameters
  • taxiOrderUuid (body, string, required)
  • refNumber (body, string, required)
GET/api/v1/da/fleet-orders/{requestId}JEKStable
https://api.jek.app
Claimed Fleet Mode Order transfer detail
Transfer detail (轉帳詳情) for a claimed order, keyed on the withdrawal request id rather than the taxi order uuid.
Auth
driver_bearer
Parameters
  • requestId (path, string, required)
Driver Assistant · Meter
POST/api/v1/da/m1os/connectJEKStable
https://api.jek.app
Pair a scanned M1OS meter
Resolves the scanned meter QR, binds the device to the driver's business and, unless `goOnline` is false, starts a device login request. `state` is `complete` (connection applied) or `pending` (poll `/m1os/login-request` with `requestId` + `deviceSn`).
Auth
driver_bearer
Parameters
  • rawScan (body, string)
  • deviceSn (body, string)
  • code (body, string)
  • goOnline (body, boolean)
POST/api/v1/da/m1os/disconnectJEKStable
https://api.jek.app
Unpair the driver's meter
Clears the local meter pairing and attempts the OMS unbind; upstream failures are ignored. The vehicle stays in the driver's list.
Auth
driver_bearer
GET/api/v1/da/m1os/login-requestJEKStable
https://api.jek.app
Poll a meter login request
Polls a Wonder device login request. On `complete` the meter is paired and, when `goOnline` is set, the driver is put on duty through the same gate as `/me/online`; `online` reports whether that happened.
Auth
driver_bearer
Parameters
  • id (query, string, required)
  • deviceSn (query, string, required)
  • goOnline (query, boolean)
  • pair (query, boolean)
DELETE/api/v1/da/m1os/login-requestJEKStable
https://api.jek.app
Cancel a meter login request
Cancels the login request upstream; always answers `cancelled: true`, even if Wonder refuses.
Auth
driver_bearer
Parameters
  • id (query, string, required)
GET/api/v1/da/m1os/statusJEKStable
https://api.jek.app
Meter connection status
Whether the driver's paired meter is still bound and to which vehicle, read live from Wonder's meter feed. Drivers with no pairing are answered without an upstream call.
Auth
driver_bearer
Driver Assistant · Onboarding
POST/api/v1/da/ocr/recognitionJEKStable
https://api.jek.app
Upload a vehicle-licence photo for OCR
Forwards a photo of the taxi's vehicle registration licence to Wonder's OCR and returns the recognition task. JPEG, PNG or HEIC; over 6 MB decoded answers 413 `IMAGE_TOO_LARGE`.
Auth
driver_bearer
Parameters
  • image (body, string, required)
GET/api/v1/da/ocr/statusJEKStable
https://api.jek.app
Poll a licence recognition
Status of one OCR task: `crawing` (keep polling), `success` or `failed` (Wonder's spellings). Reaching `success` creates the virtual meter upstream and consumes the task.
Auth
driver_bearer
Parameters
  • taskId (query, string, required)
GET/api/v1/da/ocr/taskJEKStable
https://api.jek.app
Driver's in-flight OCR task
The driver's current licence recognition task, used to resume the capture flow.
Auth
driver_bearer
DELETE/api/v1/da/ocr/taskJEKStable
https://api.jek.app
Discard the in-flight OCR task
Clears the driver's OCR task at Wonder so a new photo can be taken. Wonder holds one task per driver.
Auth
driver_bearer
GET/api/v1/da/onboarding/statusJEKStable
https://api.jek.app
Onboarding status
Whether the driver has completed onboarding (`verified`, `pending`, or `unknown` when the probe failed), whether a Wonder identity is linked, and any in-flight licence OCR task.
Auth
driver_bearer
POST/api/v1/da/virtual-meter/taskJEKStable
https://api.jek.app
Confirm a licence and create the virtual meter
Confirms a recognised OCR task so Wonder creates the driver's virtual meter, then adds the vehicle to the driver's fleet. A task Wonder has already completed still answers 200 with `outcome` saying so; `landing` reports whether the vehicle was written.
Auth
driver_bearer
Parameters
  • taskId (body, string, required)
  • task (body, object)
Driver Assistant · Payout link
GET/api/v1/da/wonder-linkJEKStable
https://api.jek.app
Wonder payout-account link status
Whether the driver has authorised a Wonder account to be paid into, plus a payout diagnosis. Attempts payout-account provisioning before reporting.
Auth
driver_bearer
POST/api/v1/da/wonder-linkJEKStable
https://api.jek.app
Start a Wonder payout-account link
Creates a BizConnect login QR for the driver to scan in their Wonder app. Render `content` as the QR and poll `/wonder-link/poll` with `server_code`; the QR expires after about 120 seconds.
Auth
driver_bearer
Parameters
  • device_id (body, string)
DELETE/api/v1/da/wonder-linkJEKStable
https://api.jek.app
Unlink the Wonder payout account
Stops JEK using the driver's Wonder authorisation. Local only: the driver revokes it in the Wonder app to remove it there too.
Auth
driver_bearer
POST/api/v1/da/wonder-link/pollJEKStable
https://api.jek.app
Poll a Wonder payout-account link
Polls the link QR. `PENDING` means keep polling; `REJECTED` / `EXPIRED` set `restart: true`; on `SUCCESS` the grant is stored against the calling driver before the answer is returned.
Auth
driver_bearer
Parameters
  • server_code (body, string, required)
  • device_id (body, string)
Driver Assistant · e-Toll
GET/api/v1/da/etoll/accountsJEKStable
https://api.jek.app
List bound HKeToll accounts
Proxies the Wonder gateway e-toll account list using the driver's sealed Wonder session. Returns a bare array of { id, username, status, accountType }.
Auth
driver_bearer
Parameters
  • x-da-session (header, string, required)
POST/api/v1/da/etoll/accountsJEKStable
https://api.jek.app
Bind an HKeToll account
Forwards the credentials to the Wonder gateway e-toll bind once, with no retries; the password is never stored, logged or echoed. Returns the account (status is usually "Verifying"), or 400 ETOLL_UPSTREAM_REJECTED when the e-toll service refuses the credentials.
Auth
driver_bearer
Parameters
  • x-da-session (header, string, required)
  • username (body, string, required)
  • password (body, string, required)
  • accountType (body, string)
POST/api/v1/da/etoll/accounts/unbindJEKStable
https://api.jek.app
Unbind an HKeToll account
Proxies the Wonder gateway e-toll unbind, which is keyed on both the record id and the username; sent once with no retries. Returns { ok: true }, or 400 ETOLL_UPSTREAM_REJECTED when the e-toll service refuses.
Auth
driver_bearer
Parameters
  • x-da-session (header, string, required)
  • id (body, string, required)
  • username (body, string, required)
GET/api/v1/da/etoll/accounts/{id}JEKStable
https://api.jek.app
Get one bound HKeToll account
Proxies the Wonder gateway e-toll account read and returns { id, username, status, accountType }.
Auth
driver_bearer
Parameters
  • id (path, string, required)
  • x-da-session (header, string, required)
PATCH/api/v1/da/etoll/accounts/{id}JEKStable
https://api.jek.app
Update HKeToll account credentials
Forwards the username and password pair to the Wonder gateway e-toll account edit once, with no retries; the upstream takes the full pair, not a partial patch. Returns the account, or 400 ETOLL_UPSTREAM_REJECTED when the e-toll service refuses.
Auth
driver_bearer
Parameters
  • id (path, string, required)
  • x-da-session (header, string, required)
  • username (body, string, required)
  • password (body, string, required)
GET/api/v1/da/etoll/person-accountJEKStable
https://api.jek.app
HKeToll personal-account record
Proxies the Wonder gateway e-toll person-account read. The object is Wonder's own shape, passed through unmapped with only the envelope removed; an empty answer becomes {}.
Auth
driver_bearer
Parameters
  • x-da-session (header, string, required)
GET/api/v1/da/etoll/transactionsJEKStable
https://api.jek.app
List HKeToll tunnel charges
Proxies the Wonder gateway e-toll transactions list and returns a bare array of normalised charges (id, trxnStatus, trxnDate, tunnel, tollAmount, plateNumber, ...). A page shorter than limit marks the end of the list.
Auth
driver_bearer
Parameters
  • x-da-session (header, string, required)
  • limit (query, integer)
  • offset (query, integer)
  • trxnStatus (query, string)
  • tunnel (query, string)
  • search (query, string)
GET/api/v1/da/etoll/transactions/{id}JEKStable
https://api.jek.app
Get one HKeToll tunnel charge
Proxies the Wonder gateway e-toll transaction read and returns the charge in the same normalised shape as the list.
Auth
driver_bearer
Parameters
  • id (path, string, required)
  • x-da-session (header, string, required)
GET/api/v1/da/etoll/tunnelsJEKStable
https://api.jek.app
List tunnels for toll filtering
Proxies the Wonder gateway e-toll tunnel list and returns [{ tunnel, tunnelTranslation }]. The tunnel key is the value the transactions list filters on.
Auth
driver_bearer
Parameters
  • x-da-session (header, string, required)
GET/api/v1/da/etoll/virtual-metersJEKStable
https://api.jek.app
List HKeToll virtual meters
Proxies the Wonder gateway e-toll virtual-meter list: vehicles HKeToll knows for the driver, from a bound account or an OCR-read vehicle licence (separate from the driver's JEK vehicles). Returns [{ id, vehicleRegistrationMark, vehicleClass, type }].
Auth
driver_bearer
Parameters
  • x-da-session (header, string, required)
Wonder-compatible Ride API
POST/api/v1/wonder/quotesJEKStable
https://api.jek.app
Quote every vehicle class for a trip (legacy OMS dialect)
Accepts the legacy `CreateQuoteDto` body (`initial_location`, `destination_location`, up to four `additional_stops`), routes the trip server-side and prices each enabled class from JEK's rate card. Answers `{ code, message, data: { quotes, batch_id, routes, map_platform } }`; the batch is stored for 10 minutes so the booking can name only `batch_id` and `selected_quote_ids`. Authenticated by the `X-Internal-Token` header (an environment console credential, a partner's issued token, or the shared dispatch token); `x-jek-env` is required and must match the credential's environment.
Auth
no auth
Parameters
  • x-jek-env (header, "staging" | "alpha" | "production", required)
  • X-Internal-Token (header, string, required)
  • X-Partner-ID (header, string)
  • initial_location (body, { lat, lng, text?, full_text?, place_id? }, required)
  • destination_location (body, { lat, lng, text?, full_text?, place_id? }, required)
  • additional_stops (body, location[])
  • vehicle_type_codes (body, string[])
POST/api/v1/wonder/taxi_ordersJEKStable
https://api.jek.app
Book a quoted ride (legacy OMS dialect)
Accepts the legacy `CreateTaxiOrderDto` body, rebuilds the trip from the stored quote batch and creates a supplier order in the environment named by `x-jek-env`. Only configured demand partners may book; the stored fare is JEK's own priced total, with the partner's `fare`/`tips` kept in metadata. `external_customer.reference_number` is the idempotency key, so a retried booking returns the original order with 200. Answers `{ code, message, data: { taxi_order } }`.
Auth
no auth
Parameters
  • x-jek-env (header, "staging" | "alpha" | "production", required)
  • X-Internal-Token (header, string, required)
  • X-Partner-ID (header, string)
  • batch_id (body, uuid, required)
  • selected_quote_ids (body, string[], required)
  • channel (body, string)
  • fare (body, decimal string (major units))
  • tips (body, decimal string (major units))
  • external_customer (body, { reference_number, nickname?, mobile?, email? })
GET/api/v1/wonder/taxi_orders/{id}JEKStable
https://api.jek.app
Read a booking (legacy OMS dialect)
Returns `{ code, message, data: { taxi_order_detail } }` with the order, driver and vehicle. `id` is either the JEK order id or the partner's own reference number; an order belonging to another partner or environment answers "Order not found".
Auth
no auth
Parameters
  • id (path, string, required)
  • x-jek-env (header, "staging" | "alpha" | "production", required)
  • X-Internal-Token (header, string, required)
  • X-Partner-ID (header, string)
PUT/api/v1/wonder/taxi_orders/{id}/cancelJEKStable
https://api.jek.app
Cancel a booking (legacy OMS dialect)
PUT matches the legacy OMS route; POST on the same path runs the same handler. Answers `{ code, message, data: { taxi_order } }` with the order in its cancelled state. An already-cancelled order is a success; a completed trip is refused with an operation-conflict code.
Auth
no auth
Parameters
  • id (path, string, required)
  • x-jek-env (header, "staging" | "alpha" | "production", required)
  • X-Internal-Token (header, string, required)
  • X-Partner-ID (header, string)
  • cancel_remark (body, string)
POST/api/v1/wonder/taxi_orders/{id}/cancelJEKStable
https://api.jek.app
Cancel a booking (POST alias)
Same handler as the PUT route, for callers not coming through the OMS proxy.
Auth
no auth
Parameters
  • id (path, string, required)
  • x-jek-env (header, "staging" | "alpha" | "production", required)
  • X-Internal-Token (header, string, required)
  • X-Partner-ID (header, string)
PUT/api/v1/wonder/taxi_orders/{id}/chat_channelJEKStable
https://api.jek.app
Attach Wonder's Sendbird chat channel to a booking
Called by Wonder to hand over the Sendbird channel it provisioned for a partner booking, after which the order renders `allow_chat: true` with a `chat_configure`. Idempotent; the channel is stored as sent and not validated with Sendbird. A completed, cancelled or expired order is refused.
Auth
no auth
Parameters
  • id (path, string, required)
  • x-jek-env (header, "staging" | "alpha" | "production", required)
  • X-Internal-Token (header, string, required)
  • chat_configure.channel (body, string, required)
  • chat_configure.passenger_id (body, string)
  • chat_configure.driver_id (body, string)
GET/api/v1/wonder/taxi_orders/{id}/rideJEKStable
https://api.jek.app
Live driver position for a booking (legacy OMS dialect)
Returns the order's state and, while it is accepted, arrived or in trip, the driver's latest position and heading if the fix is under 10 minutes old. The driver's identity is not included.
Auth
no auth
Parameters
  • id (path, string, required)
  • x-jek-env (header, "staging" | "alpha" | "production", required)
  • X-Internal-Token (header, string, required)
  • X-Partner-ID (header, string)
GET/api/v1/wonder/taxi_orders/{id}/statusJEKStable
https://api.jek.app
Order status poll (legacy OMS dialect)
What Heycars and Hoppa poll about every 4 seconds. Byte-compatible with OMS `GetTaxiOrderStatusPresenter`: while accepted, arrived or in trip and with a driver fix under 10 minutes old it returns state, location, angle and the remaining-route estimate (distance, duration, polyline, progress — measured along a cached Google leg route exactly as OMS measures it); otherwise every field is null and the estimate zero. An unknown order is HTTP 400 code 100001, as in OMS.
Auth
no auth
Parameters
  • id (path, string, required)
  • x-jek-env (header, "staging" | "alpha" | "production", required)
  • X-Internal-Token (header, string, required)
  • X-Partner-ID (header, string)