REZU OFFICE · API v1
Rezu Office API: documentation for IT teams
The Rezu Office API connects your company car park to the systems you already have. The system behind your barrier, ANPR camera or access control asks Rezu Office whether a person has a space today and gets the answer straight back. Only people with a space that day get a yes.
POST /v1/office/gate-eventsWA 12345main-gateWe install no hardware or software on your side. What you need there is something that can call the API: a barrier controller, an access-control system, or a small connector program between the camera and the barrier. Not every device can do this, so check with your installer.
Parking becomes part of the rest of your systems: the same data on who has a space today, and the bookings, can feed your HR system, an intranet “who is in today” board or your reports.
Your company admin creates and revokes API keys in the Rezu Office company panel and picks their scopes. A key is shown only once, when it is created. A ready-made integration built by us: on request, individually quoted.
What you can connect
Ask before the barrier opens
The system behind your ANPR camera or barrier sends a number plate and gets
allowordenyback.Uses:
POST /v1/office/gate-eventsCheck an access badge
An access-control system asks by the person's Rezu Office id (
memberId, returned byGET /v1/office/rostertogether with the work email), which you map to their badge.Uses:
POST /v1/office/gate-eventsShow who has a space today
Your HR system or intranet reads the list of people with a space on a given day.
Uses:
GET /v1/office/rosterCount occupancy in reports
Bookings in any status, up to 62 days per request, flow into your reports.
Uses:
GET /v1/office/bookingsReact to a released space
A webhook arrives when a space frees up for a day, so you do not have to keep asking.
Uses:
spot.released
What you get
- Documentation in English and Polish, and a downloadable OpenAPI 3.1 file.
- Signed webhooks for bookings, cancellations, released spaces and entries, so you do not have to poll the API for those changes.
- The entry decision in the response to the same request.
- Number plates only under a separate permission, and stated retention. After 30 days gate events lose the person (member, booking, space); after 90 days the plate; date, time, gate and decision stay.
- Limits stated in numbers, and what to do when the API does not answer.
For developers
For developers: HTTPS and JSON, a key in the Authorization header, separate permission scopes, idempotent gate events and webhooks signed with HMAC-SHA256. The full OpenAPI 3.1 spec is at the bottom of this page.
Quick start
https://neighbor-parking-backend.vercel.app/api1. Create a key. Your company admin creates and revokes API keys in the Rezu Office company panel and picks their scopes. A key is shown only once, when it is created. A key is rz_live_ followed by 32 characters. We keep only its SHA-256 hash and the start of the key so you can recognise it, so store the key like a password: a lost key cannot be recovered, so revoke it in the panel and create a new one. Revocation takes effect immediately.
2. Your first call. Check which company the key belongs to and which scopes it has:
curl https://neighbor-parking-backend.vercel.app/api/v1/office/me \
-H "Authorization: Bearer rz_live_YOUR_KEY"{
"organization": {
"id": "4c1f0a52-7d3e-4b8a-9f61-2a5d8e0c3b17",
"slug": "acme",
"name": "ACME"
},
"apiKey": {
"id": "b7e2d9c4-1a6f-4e3b-8d05-6c9a2f1e7b40",
"name": "Gate bridge",
"prefix": "rz_live_Ab3dE9xQ",
"scopes": [
"read:roster",
"write:gate-events"
]
},
"today": "2026-11-14"
}With no key, or a wrong one, you get a 401:
{"error":{"code":"api_key_invalid","message":"Missing or invalid API key"}}3. Who has a space on a given day. With the read:roster scope:
curl "https://neighbor-parking-backend.vercel.app/api/v1/office/roster?date=2026-11-16" \
-H "Authorization: Bearer rz_live_YOUR_KEY"Authentication and scopes
Every call sends the key in the Authorization: Bearer rz_live_... header. A key belongs to one company and sees only that company's data. You pick the scopes when you create the key; one key can hold several.
| Scope | What it allows |
|---|---|
read:roster | who has a space on a given day, with the person's name and work email; the list of locations and spaces |
read:bookings | bookings over a date range, plus the list of locations and spaces |
read:plates | number plates (GDPR: a separate scope; without it plates are never returned) |
write:gate-events | reporting entries and getting the let-in answer |
webhooks | registering and managing webhooks with this key |
A missing scope returns 403 api_key_scope_missing, with the missing scopes in details.required. Every key creation and revocation is written to an audit log.
Limits
- 120 requests per minute per key, across all endpoints. Above that:
429 rate_limited. - After 30 failed authentication attempts from one IP address within 10 minutes we answer
429. - Up to 20 active keys and 10 webhook endpoints per company.
GET /v1/office/bookingscovers at most 62 days and returns up to 1000 bookings per page (500 by default); follownextCursorfor the next page.- A gate event accepts an
occurredAtwithin the last 24 hours (default: now).
Endpoints
Paths are relative to the base URL. Dates use YYYY-MM-DD; the default time zone is Europe/Warsaw.
| Method and path | Scope | Description |
|---|---|---|
GET /v1/office/me | any | the company, the key's name and scopes, today's date |
GET /v1/office/roster | read:roster | who has a space on a given day: confirmed bookings plus fixed-space holders who did not give the day away. Parameters date (default: today) and locationId |
GET /v1/office/bookings | read:bookings | bookings in any status from from to to, filters status and locationId, paging with limit and cursor |
GET /v1/office/spots | read:roster or read:bookings | locations and spaces: type (standard, EV charger, accessible) and fixed holder |
POST /v1/office/gate-events | write:gate-events | report an entry, answer allow or deny |
GET /v1/office/webhooks | webhooks | list endpoints (secrets are never returned) |
POST /v1/office/webhooks | webhooks | register an endpoint; the secret appears only in this response |
PATCH /v1/office/webhooks/{id} | webhooks | change the URL, events or description, disable or re-enable |
DELETE /v1/office/webhooks/{id} | webhooks | delete an endpoint; pending deliveries are marked failed |
GET /v1/office/webhooks/{id}/deliveries | webhooks | delivery log, newest first |
Entry: let them in or not?
How it works: your system always asks (a barrier controller, an access-control system or the program behind an ANPR camera) and sends a number plate or the person's id. Rezu Office checks, at the moment of the request, whether that person has a confirmed booking for the day or a fixed space they did not give away, records the event and sends the decision back in the response to the same request: allow or deny. Your system opens the barrier or keeps it shut.
curl -X POST https://neighbor-parking-backend.vercel.app/api/v1/office/gate-events \
-H "Authorization: Bearer rz_live_YOUR_KEY" \
-H "Idempotency-Key: cam1-000123" \
-H "Content-Type: application/json" \
-d '{ "gateId": "main-gate", "plate": "WA 12345", "occurredAt": "2026-11-16T08:58:11+01:00" }'{
"gateEventId": "e5a1c3d7-2b4f-4a69-8c10-9d7e6f5a4b32",
"gateId": "main-gate",
"occurredAt": "2026-11-16T07:58:11.000Z",
"date": "2026-11-16",
"decision": "allow",
"hasValidBooking": true,
"reason": "booking",
"member": {
"id": "0d9c8b7a-6e5f-4d3c-b2a1-908f7e6d5c4b"
},
"booking": {
"id": "7f6e5d4c-3b2a-4190-8e7d-6c5b4a392817",
"date": "2026-11-16",
"spotId": "2a3b4c5d-6e7f-4a8b-9c0d-1e2f3a4b5c6d"
},
"spot": {
"id": "2a3b4c5d-6e7f-4a8b-9c0d-1e2f3a4b5c6d",
"label": "B-07",
"locationId": "5e6f7a8b-9c0d-4e1f-a2b3-c4d5e6f7a8b9"
},
"replayed": false
}{
"gateEventId": "c2d3e4f5-a6b7-4c8d-9e0f-1a2b3c4d5e6f",
"gateId": "main-gate",
"occurredAt": "2026-11-16T08:02:40.000Z",
"date": "2026-11-16",
"decision": "deny",
"hasValidBooking": false,
"reason": "unknown_plate",
"member": null,
"booking": null,
"spot": null,
"replayed": false
}You can send memberId instead of plate. Plates can be written any way: we uppercase them and strip spaces, dashes and dots. reason says where the decision comes from:
| reason | Decision | Meaning |
|---|---|---|
booking | allow | a confirmed booking for that day |
fixed_spot | allow | a fixed space, and the day was not given away |
no_booking | deny | the person is in your company but has no space that day |
unknown_plate | deny | nobody in your company has added this plate |
unknown_member | deny | there is nobody with this memberId in your company |
member_inactive | deny | the person's account is not active or their access has expired |
- A new event returns
201. A retry with the sameIdempotency-Key(header oridempotencyKeyfield, up to 128 characters) returns200with the first answer andreplayed: true, so you can safely retry after a dropped connection. - The same
Idempotency-Keywith a different body returns409 idempotency_key_reused. - The plate is echoed back (
plate) only to keys with theread:platesscope. - An allowed entry with a booking for today counts as an arrival check-in, so when the company requires check-ins, that space will not be released for a missing one if the entry comes before the release time.
- When a company's car park is paused after the free month, nobody has a space in it and the answer is
deny; when the company account is suspended, the API answers403 org_suspended. - Every event also sends a
gate.entrywebhook to the endpoints subscribed to it.
When the API does not answer
On a 5xx response, or when no answer arrives in time, let people in the way you do today, with a card or a remote, and retry with the same Idempotency-Key. Never treat a missing answer as a deny.
Webhooks
Webhooks are notifications Rezu Office sends to your server when something changes, so you do not have to keep polling the API.
Register with POST /v1/office/webhooks, giving a url and a list of eventTypes. The whsec_... secret is shown only once, in the response to the registration. The URL must use https, port 443 or 8443, and point to a public address. Private, loopback and link-local addresses are refused at registration and at every delivery (we resolve DNS).
curl -X POST https://neighbor-parking-backend.vercel.app/api/v1/office/webhooks \
-H "Authorization: Bearer rz_live_YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{ "url": "https://example.com/rezu", "eventTypes": ["booking.created", "booking.cancelled", "spot.released", "gate.entry"] }'| Event | When |
|---|---|
booking.created | a new booking. data.booking.source: manual (the person booked), rhythm (fixed days), lottery (the draw), waitlist (the queue), admin (an admin) or team_lead (a team lead) |
booking.cancelled | a cancellation. data.reason: member (the person cancelled), admin, team_lead, member_removed (removed from the company), member_suspended (access suspended), member_inactive (access expired), rhythm_release (fixed days gave the booking back), no_show (the company requires a check-in and none came by the release time), member_not_coming (the person tapped "not coming"), member_away (the person reported being away that day), member_not_parking (the person marked that they do not park), org_paused (the company's car park is paused) or org_terminated (the company's contract ended) |
spot.released | a space is free for a day. data.reason: holder_gave_away (the fixed holder gave the day away), holder_away (the fixed holder reported being away), booking_released, release_time (at the release time, 9:30 by default, a given-away day is still free), no_show (with bookingId) or member_not_coming |
gate.entry | a reported entry with its decision. data.source: api (reported by your system) or app (an entry recorded by the Rezu Office app, only with a gate integration agreed with us; always allow, no plate) |
New reason and source values may appear; treat an unknown one as a plain cancellation or release.
Body and headers
POST /rezu HTTP/1.1
Content-Type: application/json
User-Agent: Rezu-Webhooks/1
Rezu-Signature: t=1794815892,v1=<hex HMAC-SHA256 of "1794815892." + raw body>
Rezu-Event-Id: evt_3f9a1c0b7d2e4a6f8b5c9d1e2f3a4b5c
Rezu-Event-Type: gate.entry
Rezu-Delivery-Id: 8d7c6b5a-4f3e-4d2c-9b1a-0f9e8d7c6b5a
Rezu-Delivery-Attempt: 1{
"id": "evt_3f9a1c0b7d2e4a6f8b5c9d1e2f3a4b5c",
"type": "gate.entry",
"apiVersion": "v1",
"createdAt": "2026-11-16T07:58:12.204Z",
"organization": {
"id": "4c1f0a52-7d3e-4b8a-9f61-2a5d8e0c3b17",
"slug": "acme"
},
"data": {
"gateEventId": "e5a1c3d7-2b4f-4a69-8c10-9d7e6f5a4b32",
"gateId": "main-gate",
"source": "api",
"occurredAt": "2026-11-16T07:58:11.000Z",
"date": "2026-11-16",
"decision": "allow",
"reason": "booking",
"memberId": "0d9c8b7a-6e5f-4d3c-b2a1-908f7e6d5c4b",
"bookingId": "7f6e5d4c-3b2a-4190-8e7d-6c5b4a392817",
"spotId": "2a3b4c5d-6e7f-4a8b-9c0d-1e2f3a4b5c6d"
}
}Every event has a stable id (evt_..., also in the Rezu-Event-Id header). Delivery is at least once and not in a guaranteed order, so deduplicate on id.
Signature
The Rezu-Signature: t=<unix>,v1=<hex> header, where v1 = HMAC-SHA256(secret, "<t>.<raw body>"). Compute it over the raw body before parsing, compare in constant time and reject messages whose t is more than 5 minutes old. Check your implementation against this vector:
secret = whsec_test_vector_secret
t = 1793610000
body = {"id":"evt_test","type":"gate.entry"}
v1 = 85445fadc858b25c46b6da4dc0aa366b0499af38386a2a1a11cf76a6eaf3ee60import crypto from "node:crypto";
import express from "express";
const SECRET = process.env.REZU_WEBHOOK_SECRET; // whsec_...
function verifyRezuSignature(header, rawBody, secret, nowSeconds = Date.now() / 1000) {
const parts = Object.fromEntries(
String(header ?? "").split(",").map((p) => p.trim().split("=")).filter((kv) => kv.length === 2)
);
const t = Number(parts.t);
if (!Number.isInteger(t) || Math.abs(nowSeconds - t) > 300) return false;
if (!/^[0-9a-f]{64}$/i.test(parts.v1 ?? "")) return false;
if (!Buffer.isBuffer(rawBody)) return false;
const signed = Buffer.concat([Buffer.from(`${t}.`, "utf8"), rawBody]);
const expected = crypto.createHmac("sha256", secret).update(signed).digest();
return crypto.timingSafeEqual(Buffer.from(parts.v1, "hex"), expected);
}
const app = express();
app.post("/rezu", express.raw({ type: "application/json" }), (req, res) => {
// express.raw leaves req.body as {} when the content type does not match: no raw bytes, nothing to verify.
if (!Buffer.isBuffer(req.body)) return res.sendStatus(400);
if (!verifyRezuSignature(req.get("Rezu-Signature"), req.body, SECRET)) return res.sendStatus(400);
const event = JSON.parse(req.body.toString("utf8"));
// dedupe on event.id, then handle event.type
res.sendStatus(204);
});import hashlib, hmac, json, os, time
from flask import Flask, request, abort
SECRET = os.environ["REZU_WEBHOOK_SECRET"].encode() # whsec_...
app = Flask(__name__)
def verify_rezu_signature(header, raw, secret, now=None):
try:
parts = dict(p.strip().split("=", 1) for p in (header or "").split(","))
t = int(parts["t"])
given = bytes.fromhex(parts["v1"])
except (KeyError, ValueError):
return False
if abs((time.time() if now is None else now) - t) > 300:
return False
expected = hmac.new(secret, f"{t}.".encode() + raw, hashlib.sha256).digest()
return hmac.compare_digest(expected, given)
@app.post("/rezu")
def rezu():
raw = request.get_data() # raw bytes, before parsing
if not verify_rezu_signature(request.headers.get("Rezu-Signature"), raw, SECRET):
abort(400)
event = json.loads(raw)
# dedupe on event["id"], then handle event["type"]
return "", 204Retries
Any 2xx response within 10 seconds counts as delivered. Anything else, redirects and timeouts included, is retried no earlier than 1 min, 5 min, 30 min, 2 h, 6 h, 12 h and 24 h after the previous attempt. After 8 attempts the delivery is marked failed. After 15 failed attempts in a row the endpoint is disabled (disabledReason: "too_many_failures"); re-enable it with a PATCH of { "status": "active" }. Re-enabling does not resend failed deliveries; check the log: GET /v1/office/webhooks/{id}/deliveries. Events are kept for 30 days.
Number plates and privacy
- Each person adds their own number plates in the app, up to 3. We store them uppercase, without spaces.
- Plates leave the API only for keys with the
read:platesscope, and in webhooks only for endpoints withincludePlates: true, which also needsread:plates. - When someone leaves the company, we delete their plates from the company's list; in gate events they stay for at most 90 days.
- After 30 days gate events lose the person (member, booking, space); after 90 days the plate; date, time, gate and decision stay.
- In Rezu Office, arrival data is used to allocate spaces, and we collect no location with it. Check-in times in the app are deleted after 30 days. We also keep the entries your system reports, under the same rules; whatever you receive through the API and webhooks is then stored by you.
- The API never reads private Rezu data: vehicles saved on a personal account, phone numbers or Rezu Daily bookings.
Errors
Every error has the same shape: error.code for your code, error.message for people and an optional error.details. For validation_error, details is either an object with a reason or a list of field validation issues.
{
"error": {
"code": "api_key_scope_missing",
"message": "This API key does not have the required scope",
"details": {
"required": [
"write:gate-events"
],
"mode": "any"
}
}
}| Status | Code | Meaning |
|---|---|---|
| 400 | validation_error | a malformed request; details says what to fix (for example invalid_plate, occurred_at_out_of_range, range_too_long, invalid_cursor) |
| 400 | webhook_url_not_allowed | the webhook URL is not allowed (details.reason) |
| 401 | api_key_invalid | no key, or an unknown key |
| 401 | api_key_revoked | the key has been revoked |
| 403 | api_key_scope_missing | the key lacks a required scope (details.required) |
| 403 | org_suspended | the company account is suspended |
| 404 | feature_disabled | Rezu Office is not enabled |
| 404 | webhook_endpoint_not_found | no such webhook endpoint |
| 409 | idempotency_key_reused | the same Idempotency-Key with a different body |
| 409 | conflict | a parallel request with the same Idempotency-Key; retry with the same key |
| 409 | webhook_endpoint_limit_reached | the company already has 10 webhook endpoints |
| 429 | rate_limited | too many requests, or too many failed authentication attempts |
| 500 | internal_error | an error on our side; retry, for entries with the same Idempotency-Key |
| 503 | maintenance_mode | planned maintenance; handle it like a missing answer |
OpenAPI specification
The full machine-readable spec: paths, parameters, response schemas, error codes and webhooks. Load it into any tool that supports OpenAPI 3.1.
Questions about the API: kontakt@getrezu.pl. How Rezu Office itself works: Rezu Office for business.
Questions
Does Rezu Office have an open API?
Yes. The Rezu Office API is documented on this page in English and Polish, and the full spec is in a downloadable OpenAPI 3.1 file. Company admins create API keys in the company panel.
What can we connect?
Anything that can call the API: a barrier controller, an access-control system or a small connector program between an ANPR camera and the barrier, as well as an HR system, an intranet or a reporting tool. It asks who has a space, reads bookings and receives webhooks about changes.
Do you install anything on our side?
We install no hardware or software on your side. What you need there is something that can call the API: a barrier controller, an access-control system, or a small connector program between the camera and the barrier. Not every device can do this, so check with your installer. A ready-made integration built by us: on request, individually quoted.
Will our barrier or camera work with it?
It depends on what you have. A programmable access-control system or barrier controller needs to be configured or programmed to call the API. A camera that only reads plates needs a small connector program on your side, which sends the plate to the API and signals the barrier based on the answer. A remote-only barrier with no network connection needs a controller added. Without any integration, people drive in as today, with a card or a remote, and Rezu Office only allocates spaces.
Does Rezu Office open the gate?
Not through the API. Through the API, Rezu Office only answers whether a person has a space today; your system opens the barrier.
How do we get an API key?
Your company admin creates and revokes API keys in the Rezu Office company panel and picks their scopes. A key is shown only once, when it is created.
What about number plates and GDPR?
Each person adds their own plates in the app, and plates leave the API only for keys with the separate read:plates scope. After 30 days gate events lose the person (member, booking, space); after 90 days the plate; date, time, gate and decision stay. We also keep the entries your system reports, under the same rules; whatever you receive through the API and webhooks is then stored by you.
What if the API does not answer?
Let people in the way you do today, with a card or a remote, and retry with the same Idempotency-Key. A missing answer is not a deny.
First the garage, then the integration.
Rezu Office works without any integration: people book spaces in the app and drive in as they do today, with a card or a remote. Connect the API whenever you are ready.