Developers

Build on MemberArea with a real REST API

Members, courses, orders and payments behind one versioned API. Authenticate with an API key or OAuth 2.0, react to signed webhooks and start from the OpenAPI spec.

180
API operations
38
Webhook events
34
OAuth scopes
curl
curl "https://api.memberarea.io/v1/members?per_page=5&include=tags" \
  -H "X-Api-Key: mak_your_key"
Quickstart

Your first request in two minutes

Create an API key in the admin under Settings, API. Send it in the X-Api-Key header, or as a bearer token, and every response comes back as JSON with the records in data and the paging in meta.

  • Base URL https://api.memberarea.io/v1
  • Keys start with mak_ and are shown once
  • 25 records per page, up to 100 with per_page
  • Members are addressed by UUID, never by an internal id
Read the API reference
JSON
{
  "data": [
    {
      "id": "9b1f6c2e-4d0a-4c55-9a3e-2f7d1c8b6a10",
      "first_name": "Lena",
      "last_name": "Weber",
      "email": "lena@example.com",
      "status": 1,
      "created_at": "2026-10-02T09:14:00+00:00",
      "tags": [
        {
          "id": "4f2a9c71-0b3e-4d8a-a6c5-7e1d2b9f8a34",
          "name": "VIP",
          "color": "#f59e0b",
          "assigned_at": "2026-10-02T09:15:00+00:00"
        }
      ]
    }
  ],
  "meta": { "page": 1, "per_page": 5, "total": 128, "last_page": 26 }
}
Authentication

API keys for your own scripts, OAuth for apps

An API key belongs to one account and fits server-to-server jobs. An app that other MemberArea accounts connect to uses OAuth 2.0 with the authorization code flow and PKCE, so every account approves exactly the scopes it grants.

  • Register apps under Settings, OAuth Apps
  • PKCE with S256, public and confidential clients
  • Access tokens last one hour, refresh tokens 60 days
  • Discovery at /.well-known/oauth-authorization-server
1. Authorize
https://app.memberarea.io/oauth/authorize
  ?response_type=code
  &client_id=mac_your_client
  &redirect_uri=https://yourapp.com/callback
  &scope=members:read courses:read
  &state=random_state
  &code_challenge=BASE64URL_SHA256_OF_VERIFIER
  &code_challenge_method=S256
2. Exchange the code
curl -X POST https://app.memberarea.io/oauth/token \
  -d grant_type=authorization_code \
  -d code=CODE_FROM_CALLBACK \
  -d redirect_uri=https://yourapp.com/callback \
  -d client_id=mac_your_client \
  -d client_secret=mas_your_secret \
  -d code_verifier=YOUR_VERIFIER
  • Granular scopes

    Read and write are separate scopes per resource, for example members:read, members:write, courses:read or payments:read.

  • Rotate and revoke

    Revoke a key or a token at any time. Every other integration keeps running.

  • Plan-gated and audited

    API access follows the plan of the account, and every key shows when it was last used.

Webhooks

Signed events, verified in ten lines

Webhooks follow the Standard Webhooks specification. Each delivery carries webhook-id, webhook-timestamp and webhook-signature, an HMAC-SHA256 over id, timestamp and raw body, keyed with your whsec_ secret.

  • Reject deliveries older than five minutes
  • Failed deliveries are retried automatically
  • Every attempt lands in the delivery log
  • Subscribe and unsubscribe through the API with webhooks:manage
Node.js
import crypto from "node:crypto";

export function verify(req, rawBody, secret) {
  const { "webhook-id": id, "webhook-timestamp": ts, "webhook-signature": sig = "" } = req.headers;
  if (!id || !ts || Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false;

  const key = Buffer.from(secret.slice(6), "base64");
  const mac = crypto.createHmac("sha256", key).update(`${id}.${ts}.${rawBody}`).digest("base64");
  const expected = Buffer.from(`v1,${mac}`);

  return sig.split(" ").some((s) => {
    const given = Buffer.from(s);
    return given.length === expected.length && crypto.timingSafeEqual(given, expected);
  });
}

Limits and errors

Predictable limits, readable errors

Every limit is announced in the response headers, and every error has the same shape, so a client can handle them once.

  • Rate limits

    600 reads, 120 writes and 30 automation triggers per minute, plus a daily cap. Above that the API answers 429 with Retry-After.

  • Pagination

    page and per_page in, page, per_page, total and last_page out in meta.

  • One error shape

    error.code for your code, error.message for people and error.details for the fields that failed.

  • Plan limits

    When an account reaches a limit of its plan, the API answers 402 with plan_limit_reached.

HTTP
HTTP/1.1 429 Too Many Requests
Retry-After: 12
X-RateLimit-Limit: 120
X-RateLimit-Remaining: 0

{
  "error": {
    "code": "rate_limited",
    "message": "Too many requests. Retry in 12s.",
    "window": "minute"
  }
}

Resources

Everything you need to start building

The reference, the machine-readable spec and the OAuth metadata, always generated from the same source.

  • API reference

    Every endpoint with parameters, examples and the scope it needs, in your language.

    Open the reference
  • OpenAPI 3.1 spec

    Import it into Postman or Insomnia, or generate a client in the language you work in.

    Download openapi.json
  • OAuth metadata

    Endpoints, grant types and supported scopes as RFC 8414 discovery document.

    View the metadata
MemberArea

Start building on MemberArea

Create your API key during the 14-day free trial.

No credit card required. Cancel anytime.