Open-source multi-tenant API gateway
Turn your microservices
into multi-tenant products.
Before your code runs, the SOAJS gateway knows which customer is calling, what they are allowed to use and who the user is. Tenant keys, per-API ACL and OAuth work together, so each customer gets exactly the access in their package. Rate limiting, caching and idempotency come with it. You write the business logic.
service.get('/orders', (req, res) => {
// The gateway already resolved the tenant, applied
// its package ACL to this API and checked the user.
const { tenant, urac, inputmaskData } = req.soajs;
orders.list(tenant.id, urac._id, inputmaskData, (err, data) =>
res.json(req.soajs.buildResponse(err, data)));
});New · MCP for AI agents
Every service is an MCP tool. With each customer's permissions.
AI agents connect to one gateway endpoint and see your APIs as tools. The tenant's package and the user's ACL decide which ones, exactly as they do for your apps. A tool call is an ordinary API call: OAuth, ACL, rate limiting and idempotency apply before your service runs.
- No MCP server to write. SOAJS services describe their APIs from
config.js; Node.js, Python and Go services from their Swagger. - No second permission system. An agent gets what its key's package and its user allow. Give agents their own key and package to narrow it further.
- No way around your rules. Every tool call goes through the same gateway checks as any other call, and counts toward your rate limits and activity tracking.
{
"mcpServers": {
"acme": {
"url": "https://api.example.com/soajs/mcp",
"headers": {
"key": "<Acme's agent key>",
"Authorization": "Bearer <user token>"
}
}
}
}Sound familiar?
The plumbing every multi-tenant product ends up rebuilding
Every customer needs different access
Plans, partners and enterprise deals turn into per-customer flags and special cases in business logic, one if at a time.
With SOAJS: each customer's key maps to a product package, and its ACL decides, API by API, what that customer can call.
Every service re-implements auth
Copy-pasted token checks drift across teams and languages until nobody is sure which rules apply where.
With SOAJS: OAuth tokens, tenant keys and user groups are checked once, at the gateway, for every service.
Traffic rules live in ten places
Rate limits, response caches and safe retries get rebuilt in each service, or skipped.
With SOAJS: rate limiting, GET caching and Idempotency-Key replay protection are gateway settings, per service.
Sockets and jobs skip the rules
Real-time servers and background workers grow a second, weaker copy of your access control.
With SOAJS: they authenticate through the same gateway and get the same ACL as HTTP calls.
Tenants × ACL × OAuth
One set of services. Every customer gets exactly what they bought.
The power is in the combination. The key says which customer is calling, their package's ACL says what they can reach, and the OAuth token says which user is acting. The gateway applies all three on every request.
| Caller | GET /catalog | POST /orders | GET /reports |
|---|---|---|---|
| AcmePro package | Public | Signed-in users | Managers group only |
| GlobexBasic package | Public | Signed-in users | Not in package |
| StorefrontGuest package | Public | Not in package | Not in package |
Same service, same code. Only the package each key belongs to is different.
- The key picks the tenant and the package. Each customer application gets its own external keys, with their own expiry.
- The package ACL decides each API. Public, signed-in only, or limited to user groups, per environment, service version and HTTP method.
- The OAuth user can widen or narrow access. URAC groups can grant their own packages, so an admin inside a tenant sees more than a regular user.
- Change access without touching services. Update a package in the console and the gateway enforces it for every service behind it.
What you stop writing
Every check runs before your code does
Every call goes through the same ordered pipeline. Set extKeyRequired, oauth andurac in a service's config and it gets all of them, with no auth code in the service.
- Protect the edgeIP ban list and global maintenance mode.
- Resolve the tenantThe external key identifies tenant, application and product package.
- Check the package ACLIs this service, version and API in the package the key belongs to?
- Validate the tokenOAuth access token, including tenant-restricted and device-bound tokens.
- Apply user and tenant accessURAC user, group and per-tenant overrides.
- Shape trafficIdempotency-Key replay protection, rate limiting and GET response caching.
- Route the callFound through the service registry and forwarded with tenant context attached.
The gateway, in full
Everything the gateway does for every service behind it
All of it is configuration: in the registry, the console or a service's config file. None of it is code in your services.
Tenants & keys
- Tenant, application and product package resolved from each external key
- Key expiry dates
- Per-key IP allow and deny lists
- Per-key device rules by browser and user agent
- Per-tenant service configuration and tenant profiles
- Package overrides per network
Access control
- Package ACL per environment, service, version, HTTP method and API
- Public, signed-in or group-only APIs
- Restricted mode: only listed APIs are reachable
- Application-level ACL overrides
- User groups that grant their own packages
- Memberships resolved per product
/soajs/aclso sockets and other servers share the same rules/soajs/mcp: the same APIs as MCP tools for AI agents
Identity & tokens
- OAuth 2.0 access tokens checked on every private API
- The signed-in user and their groups forwarded to your service
- Tenant-restricted tokens for cross-tenant pairing
- Device-bound tokens checked against a
device-idheader - Login through the oauth service: password, LDAP, OpenAM, social, Azure AD, PIN or phone code
Traffic
- Rate limiting by tenant or by tenant and IP
- Separate strategies for public and private APIs, overridable per service
- IP ban list
- GET response caching with per-API TTL, in memory or MongoDB
- Idempotency-Key replay protection for writes
- CORS settings per environment
Routing & operations
- Service registry and discovery, routing by service name and version
- Tenant and user context forwarded on every call
- Proxy calls to another environment's gateway with its own key
- Roaming between deployments, carrying the verified tenant and user
- Global and per-service maintenance mode, readiness checks and registry reload
- Last-seen tracking with triggers by service, method or API
- Error logs with sensitive values redacted
Runs where you do
- Node.js gateway on Express 5, scaled out with replicas
- Go gateway 4.4.34, answering as the Node.js gateway does
- Kubernetes with Helm, cloud or on-prem
- Fully air-gapped deployments
- Services in Node.js, Go or Python behind the same rules
How it fits together
A multi-tenant, real-time product on SOAJS
Apps, a real-time server, background jobs and your own services all go through one gateway. Tenancy, ACL and tokens are decided there, once.
Swipe sideways to see the whole diagram.
- API calls. Each client app has its own external key, tied to a tenant and a product package. Every request carries that key and the user's access token, and the gateway runs steps 1–6 before your code executes. Device-bound tokens also need the matching
device-idheader. - Real-time. Your socket server doesn't need its own auth. It validates each connection's key and token with the gateway's
/soajs/aclendpoint, then sends API calls through the same gateway pipeline as HTTPS traffic, so one ACL covers both. - Service to service. Services call each other and the core services through SOAJS inter-service connections, with tenant and user context carried on each call. A service only declares
extKeyRequired,oauthanduracin its config; it writes no authentication code. - Jobs and deployments. Background jobs are clients too: they call the gateway with their own tenant key and get the same ACL. Model each customer, region or network as a tenant to keep their data and access apart.
- AI agents. Agents connect over MCP to
/soajs/mcpwith their own tenant key and a user's token. They see the APIs that key's package and that user allow as tools, and every tool call goes through steps 1–6 like any API call. MCP for AI agents
Connect Spaces runs this pattern in production: 23 microservices and a Socket.IO real-time layer behind one SOAJS gateway. Read the case study.
Beyond the gateway
The rest of the platform
Input validation
Declare each API's inputs, sources and JSON-schema validation in config. Requests arrive at your handler already mapped and validated.
Users, groups and login
The urac and oauth services manage users, groups, invitations and every login method, per tenant.
Console and marketplace
A web console for environments, tenants, keys, products, packages, the service catalog, Git repositories and infrastructure.
Deploy and SDKs
Helm charts for every core service, in-container deployment from source, and SDKs for Node.js, Go and Python.
Configuration, not boilerplate
Three flags instead of an auth layer
A service's config tells the gateway who may call it, which APIs it exposes, and how each input is sourced and validated. By the time your handler runs, the caller is known and the input inreq.soajs.inputmaskData is already clean.
module.exports = {
type: 'service',
serviceName: 'orders',
serviceGroup: 'commerce',
servicePort: 4100,
requestTimeout: 30,
extKeyRequired: true, // tenant key + package ACL
oauth: true, // access token required
urac: true, // user context on req.soajs
maintenance: { readiness: '/heartbeat', port: { type: 'maintenance' } },
schema: {
get: {
'/orders': {
_apiInfo: { l: 'List orders', group: 'Orders' },
limit: {
source: ['query.limit'],
default: 50,
validation: { type: 'integer' }
}
}
}
}
};Built on SOAJS
We build our own products on it
Encrypted communications, regulated healthcare, IoT, fintech and social: our team runs each of these on SOAJS. Many more products have been built on it by other teams.
- 126
- microservices across our products
- 7
- multi-tenant products
- 23
- services behind a single gateway in Connect Spaces
Connect Spaces
Secure communications
Chat, end-to-end-encrypted calls and meetings, with separate Spaces per organisation, deployed in the cloud or fully air-gapped.
Aomie
Regulated healthcare
A multi-tenant platform for regulated medical-cannabis care: patients, prescriptions, catalog, orders and compliance, with AI-assisted prescription processing.
INFLUENCE by The London Fund
Venture and capital operations
A venture-as-a-service operating system covering deals, campaigns, accounts and e-signature, with an event-driven financial back end.
Coupond
Retail loyalty and promotions
A loyalty and promotions platform with a rules-based promotions engine, catalog, scan analytics and point-of-sale integrations.
Nell
IoT orchestration
Multi-network IoT orchestration across LoRaWAN, BLE, GPS and Wi-Fi, with fleet device management and logistics tools.
Carrot
Social media and web3
A blockchain-enabled social platform built around modular content Cards, with creator-governed access, AI moderation and tokenised ownership.
SLIC
Creator–brand marketplace
A marketplace connecting creators and brands, with campaign workflows, automated payouts and ROI reporting.
Try it on your own cluster
Install the gateway and core services with Helm, then put your first service behind it.