API documentation
A simple JSON API over HTTPS, plus webhooks that call your server when something happens. With a key, create, schedule, update and end your meetings, read their sessions, list your recordings, read your package and orders, and manage your webhook endpoints.
Base address
https://aiomeeting.com/api/v1/<route>
Every answer is JSON. Open https://aiomeeting.com/api/v1 for the live index: it lists every route with its method and scope. Query parameters go in the address for GET; a POST or PATCH body may be a form (application/x-www-form-urlencoded) or JSON (application/json). Money is in USD. Times are YYYY-MM-DD HH:MM:SS in the site's time zone.
Authentication
Routes marked public work without a key, at a lower rate limit. Every other route needs an API key.
Send the key in the Authorization header, or in an X-API-Key header. A key looks like am_ + 12 characters + _ + 40 characters; only a fingerprint of it is stored, so copy it when it is shown.
Authorization: Bearer am_xxxxxxxxxxxx_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Sign in or create an account, then make a key under API Keys (up to 5 per account). A key can be limited to a list of IP addresses and given an end date.
A revoked key, an expired key, a key used from an address outside its list, or a key of a suspended account answers 401 or 403. API access is part of these packages: Pro, Business, Enterprise.
Scopes
A key holds one or more scopes; a route needs the scope shown next to it. Pick the fewest scopes the integration needs.
public- no key neededread- Read: your account, package and notificationsmeetings- Create, list, update and delete meetingsrecordings- List and delete recordingswebhooks- Webhooks: manage your endpoints
Rate limits
- Without a key: 30 requests per minute per IP address.
- With a key: 120 requests per minute by default. Staff can give a key its own limit.
When the limit is reached the API answers 429 with "error": "Rate limit reached...". Wait a minute and try again; do not retry in a tight loop.
Errors
Every answer carries "ok". A failure has "ok": false, an "error" text meant for a human, and an HTTP status that says what kind of failure it was:
{
"ok": false,
"error": "This key lacks the \"meetings\" scope"
}
| Status | Meaning |
|---|---|
200 | Done. The answer has "ok": true and the data. |
400 | The request was understood but refused by a rule: a start time in the past, a meeting that is not yours, more participants than the package allows, a webhook address that is not https. The error text says which. |
401 | No key, an invalid key, or a route that needs a key. |
403 | The key lacks the scope, is used from a wrong address, its account is not active, or the package has no API access. |
404 | Unknown route (the answer lists the routes) or unknown version. |
405 | Wrong method: the answer names the one to use. |
429 | Rate limit reached. |
Versioning
The version is the first path segment: /api/v1. Within v1, fields are added but not removed or renamed; new routes appear in the index. Any address without v1 answers 404 and points here. A breaking change would ship as /api/v2 next to v1, and v1 would keep working for at least a year after that.
Routes
18 routes, read from the running API
Public routes no key
| Route | Method | What it does |
|---|---|---|
/api/v1/events | GET | The webhook event types |
Read scope read
| Route | Method | What it does |
|---|---|---|
/api/v1/me/notifications | GET | Your newest notifications |
/api/v1/membership | GET | My package and its features |
/api/v1/orders | GET | My orders: ?status=open|closed|all |
/api/v1/me | GET | The account behind the key |
Meetings scope meetings
| Route | Method | What it does |
|---|---|---|
/api/v1/meetings/{id}/sessions | GET | |
/api/v1/meetings/{id}/end | POST | |
/api/v1/meetings/{id} | GET | |
/api/v1/meetings/{id} | PATCH | |
/api/v1/meetings/{id} | DELETE | |
/api/v1/meetings | GET | |
/api/v1/meetings | POST |
Recordings scope recordings
| Route | Method | What it does |
|---|---|---|
/api/v1/recordings/{id} | DELETE | |
/api/v1/recordings | GET |
Webhooks scope webhooks
| Route | Method | What it does |
|---|---|---|
/api/v1/webhook-create | POST | Add an endpoint: url, events (array or comma list), description. The secret is returned once. |
/api/v1/webhook-delete | POST | Remove an endpoint: /api/v1/webhook-delete/<id> |
/api/v1/webhook-ping | POST | Send a test ping: /api/v1/webhook-ping/<id> |
/api/v1/webhooks | GET | My webhook endpoints |
Routes written with {id} or /<id> take the id as a path segment, for example GET /api/v1/meetings/318. Lists are paged with page; the answer carries total and, where it applies, per_page.
Examples
The account behind the key (scope read)
curl -H "Authorization: Bearer YOUR_KEY" "https://aiomeeting.com/api/v1/me"
Your package and its limits (scope read)
curl -H "Authorization: Bearer YOUR_KEY" "https://aiomeeting.com/api/v1/membership"
Your upcoming meetings (scope meetings)
curl -H "Authorization: Bearer YOUR_KEY" "https://aiomeeting.com/api/v1/meetings?filter=upcoming"
Schedule a meeting (scope meetings)
curl -X POST -H "Authorization: Bearer YOUR_KEY" -H "Content-Type: application/json" \
-d '{"title":"Weekly team call","kind":"scheduled","starts_at":"2026-12-01 10:00","timezone":"Asia/Dhaka","duration_min":45,"waiting_room":1}' \
"https://aiomeeting.com/api/v1/meetings"
Your recordings (scope recordings)
curl -H "Authorization: Bearer YOUR_KEY" "https://aiomeeting.com/api/v1/recordings"
Register a webhook endpoint (scope webhooks)
curl -X POST -H "Authorization: Bearer YOUR_KEY" -H "Content-Type: application/json" \
-d '{"url":"https://example.com/hooks/aiomeeting","events":["meeting.started","meeting.ended","recording.ready"],"description":"My CRM"}' \
"https://aiomeeting.com/api/v1/webhook-create"
The answer carries the endpoint secret once. Keep it with your receiver; it is not returned again.
Webhooks
We call your server when something happens to your meetings, recordings, orders or package.
Register an https endpoint under API Keys -> Webhooks or through POST /api/v1/webhook-create, and pick the events. Each account keeps up to 3 endpoints. Private network addresses and plain http are refused.
Events
| Event | Group | Sent when |
|---|---|---|
order.created | Orders | An order was placed |
order.paid | Orders | An order was paid |
order.completed | Orders | An order completed |
order.cancelled | Orders | An order was cancelled or refunded |
subscription.updated | Account | My package changed |
ping | Account | Test ping |
meeting.started | Meetings | A meeting started |
meeting.ended | Meetings | A meeting ended |
participant.joined | Meetings | Someone joined a meeting |
participant.left | Meetings | Someone left a meeting |
recording.ready | Meetings | A cloud recording is ready |
The same list is at GET /api/v1/events. Subscribing to * through the API receives every event.
The delivery
A delivery is one POST with a JSON body. id is the delivery id, event the name, created_at the time of the event (UTC), site the site address and data the facts: ids, the meeting code and title, amounts in USD, the status. Payloads carry public facts only; read the record through the API for the rest.
{
"id": "evt_9f1c2a7b3d4e5f6a7b8c9d0e",
"event": "meeting.ended",
"created_at": "2026-11-22T13:54:16+00:00",
"site": "https://aiomeeting.com/",
"data": {
"meeting_id": 318,
"code": "12345678901",
"title": "Weekly team call",
"session_id": 1042,
"seconds": 2520,
"participants": 6,
"reason": "host"
}
}
Headers and the signature
Every delivery is a JSON POST with these headers:
| X-AIOM-Event | the event name, for example meeting.ended |
|---|---|
| X-AIOM-Delivery | the delivery id (evt_...); the same id on every retry, so you can ignore a repeat |
| X-AIOM-Timestamp | Unix time when it was sent; refuse it when older than 5 minutes |
| X-AIOM-Signature | sha256= HMAC-SHA256 of timestamp + "." + raw body with your endpoint secret |
Compute the HMAC over the raw request body, compare with a constant-time function, then answer 2xx within 10 seconds. Anything else is retried.
POST /hooks/aiomeeting HTTP/1.1 Content-Type: application/json User-Agent: AIOMeeting-Webhooks/1.3.0 X-AIOM-Event: meeting.ended X-AIOM-Delivery: evt_9f1c2a7b3d4e5f6a7b8c9d0e X-AIOM-Timestamp: 1795355656 X-AIOM-Signature: sha256=<hex HMAC-SHA256(secret, timestamp + "." + body)>
Sign the raw body bytes exactly as received, never a re-encoded copy. Rotate the secret from the endpoint page whenever it may have leaked; the old secret stops working at once.
Verify in PHP
<?php
$secret = getenv('AIOM_WEBHOOK_SECRET'); // the secret shown once when you made the endpoint
$body = file_get_contents('php://input');
$ts = $_SERVER['HTTP_X_AIOM_TIMESTAMP'] ?? '';
$sig = $_SERVER['HTTP_X_AIOM_SIGNATURE'] ?? '';
$want = 'sha256=' . hash_hmac('sha256', $ts . '.' . $body, $secret);
if (!hash_equals($want, $sig) || abs(time() - (int) $ts) > 300) {
http_response_code(400);
exit('bad signature');
}
$event = json_decode($body, true);
// $event['id'] is the delivery id: store it and skip a repeat
// $event['event'] is the name, $event['data'] the facts
http_response_code(200);
echo 'ok';
Verify in Node.js
const crypto = require('crypto');
const express = require('express');
const app = express();
const secret = process.env.AIOM_WEBHOOK_SECRET;
app.post('/hooks/aiomeeting', express.raw({ type: 'application/json' }), (req, res) => {
const ts = req.get('X-AIOM-Timestamp') || '';
const sig = req.get('X-AIOM-Signature') || '';
const want = 'sha256=' + crypto.createHmac('sha256', secret).update(ts + '.' + req.body).digest('hex');
const fresh = Math.abs(Date.now() / 1000 - Number(ts)) <= 300;
if (!fresh || want.length !== sig.length || !crypto.timingSafeEqual(Buffer.from(want), Buffer.from(sig))) {
return res.status(400).send('bad signature');
}
const event = JSON.parse(req.body.toString());
// event.id is the delivery id: remember it and skip a repeat
res.status(200).send('ok');
});
app.listen(3000);
Answers, retries and switching off
- Answer any 2xx status within 10 seconds. Do the work after answering when it takes longer; we only look at the status.
- A timeout, a connection error or any other status is a failed attempt. We try again after 1 min, 5 min, 30 min, 2 h, 12 h; after the last try the delivery is marked failed. Redirects are not followed.
- After 20 failed deliveries in a row the endpoint is switched off and you receive an e-mail. Fix the receiver, then switch it on again from the endpoint page; a successful delivery resets the count.
- Every delivery and its answer is listed on the endpoint page, and any delivery can be re-sent from there by hand.
Idempotency
A retry carries the same X-AIOM-Delivery id and the same body as the first attempt, only the timestamp and signature differ. Store the ids you have handled (a day is enough) and answer 200 without acting when one comes again. Events can also arrive out of order after a retry: compare created_at or read the record through the API before acting on a status.
Test your receiver with the Send a test ping button: it delivers a ping event at once and shows the status and answer your server gave.
Need help with the API or webhooks?
Write to us and tell us what you are building.