Skip to content

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 needed
  • read - Read: your account, package and notifications
  • meetings - Create, list, update and delete meetings
  • recordings - List and delete recordings
  • webhooks - 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"
}
StatusMeaning
200Done. The answer has "ok": true and the data.
400The 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.
401No key, an invalid key, or a route that needs a key.
403The key lacks the scope, is used from a wrong address, its account is not active, or the package has no API access.
404Unknown route (the answer lists the routes) or unknown version.
405Wrong method: the answer names the one to use.
429Rate 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

RouteMethodWhat it does
/api/v1/eventsGETThe webhook event types

Read scope read

RouteMethodWhat it does
/api/v1/me/notificationsGETYour newest notifications
/api/v1/membershipGETMy package and its features
/api/v1/ordersGETMy orders: ?status=open|closed|all
/api/v1/meGETThe account behind the key

Meetings scope meetings

RouteMethodWhat it does
/api/v1/meetings/{id}/sessionsGET
/api/v1/meetings/{id}/endPOST
/api/v1/meetings/{id}GET
/api/v1/meetings/{id}PATCH
/api/v1/meetings/{id}DELETE
/api/v1/meetingsGET
/api/v1/meetingsPOST

Recordings scope recordings

RouteMethodWhat it does
/api/v1/recordings/{id}DELETE
/api/v1/recordingsGET

Webhooks scope webhooks

RouteMethodWhat it does
/api/v1/webhook-createPOSTAdd an endpoint: url, events (array or comma list), description. The secret is returned once.
/api/v1/webhook-deletePOSTRemove an endpoint: /api/v1/webhook-delete/<id>
/api/v1/webhook-pingPOSTSend a test ping: /api/v1/webhook-ping/<id>
/api/v1/webhooksGETMy 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

EventGroupSent when
order.createdOrdersAn order was placed
order.paidOrdersAn order was paid
order.completedOrdersAn order completed
order.cancelledOrdersAn order was cancelled or refunded
subscription.updatedAccountMy package changed
pingAccountTest ping
meeting.startedMeetingsA meeting started
meeting.endedMeetingsA meeting ended
participant.joinedMeetingsSomeone joined a meeting
participant.leftMeetingsSomeone left a meeting
recording.readyMeetingsA 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:36:29+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-Eventthe event name, for example meeting.ended
X-AIOM-Deliverythe delivery id (evt_...); the same id on every retry, so you can ignore a repeat
X-AIOM-TimestampUnix time when it was sent; refuse it when older than 5 minutes
X-AIOM-Signaturesha256= 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: 1795354589
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.