$5 free credits when you sign up
Teams

Built for teams, not solo devs.

Roles, permissions, org isolation, and unlimited members on every plan. Add your whole team — no per-seat pricing, no feature gating, no cross-tenant leakage.

acme-inc · team roster

Team membership

sarah@acme.coOwner
james@acme.coAdmin
alex@acme.coMember
casey@acme.coViewer
morgan@acme.copending
Members total14 / unlimited
RLS-scopedsingle-orgaudit-logged
Roles
4

Owner, Admin, Member, Viewer

Org membership
1 user / 1 org

Database-enforced unique index

Invitation expiry
Configurable

Default 7 days, single-use tokens

Per-team budgets
Configurable

RPM/TPM + monthly spend ceilings

Capabilities

Everything your team needs on day one

Four roles with precise permissions, email invitations with expiry, per-customer spend tracking, and full multi-tenant isolation — enforced at the database level, not in application code.

Four roles, precise scope

Owner manages billing and the org itself. Admin handles all CRUD without billing. Member uses keys and reads everything. Viewer is read-only. Roles are enforced on every API call, not the UI.

  • Role checks live in middleware — never trust the client
  • Last-owner guard prevents accidental org lock-out
  • Promote/demote any member from the Team page
  • Audit trail captures every role change with actor + IP

Email invitations with expiry

Invite teammates by email with a one-click accept flow. Tokens are single-use, time-bounded, and rejected if the invitee already belongs to another org.

  • Pending invitations visible to admins for revocation
  • Accept flow rejects users who already have an org
  • Invite emails sent via SendGrid with DMARC alignment
  • Bulk invite via CSV on Tier 2 + Enterprise

Single-org-per-user, by design

Every user belongs to exactly one organization, enforced by a unique database index on the org-membership table. No multi-org switching, no ambient org selection, no cross-tenant context bleed.

  • Database constraint, not a code-level check
  • Signup, invite, and accept-invite all reject duplicate membership
  • No org-switcher UI — one identity, one tenant, one bill
  • Leave-and-rejoin is the only path to change orgs

Customer (end-user) tracking

Pass a `customer_id` on each request and see per-end-user spend, token usage, and request volume in the dashboard. Bill your customers however your pricing model wants.

  • Tag requests via the standard OpenAI metadata field
  • Group spend by customer in usage analytics
  • Per-customer budgets enforce 402 at the gateway
  • Works with the unmodified OpenAI SDK

Unlimited members, every tier

No per-seat pricing on any plan. Add your whole engineering org — Tier 1, Tier 2, Tier 3, or Enterprise — and pay only for the LLM usage they generate.

  • Same membership model on every paid tier
  • No "Enterprise" gate on roles, audit, or invitations
  • Tier difference is platform-fee + RPM/TPM, not features
  • Invite the design team, the data team, the support team

Per-team budgets and quotas

Configure RPM, TPM, and monthly spend ceilings per team. Breach the limit and the gateway returns 402 cleanly — no partial debit, no surprise bill.

  • Soft + hard caps with email + Slack alert thresholds
  • Budget enforcement happens at reserve-credit time
  • Per-team observability dashboards (spend, latency, errors)
  • Reset cycle aligns with the org billing period
Permission Matrix

What every role can actually do

The matrix below is the contract enforced in middleware on every request. Owner is the only role that can touch billing or delete the org; Viewer can read but never write.

Role-based access

Roles enforced at the API boundary, not the UI

Hiding a button is not security. Every Nemo API route validates role + organization_id before any read or write. Browser console hacks, replayed requests, and rogue tokens all hit the same wall.

  • Owner — full access including billing, plan, and org delete
  • Admin — full CRUD across keys, members, prompts, guardrails
  • Member — create + use keys, read team data, no admin writes
  • Viewer — read-only across the whole org
middleware · role check

Permission outcome

Owner: DELETE /v1/organizationallow
Admin: PATCH /nemo/guardrails/:idallow
Member: POST /v1/keysallow
Member: PATCH /nemo/billingdeny
Viewer: POST /v1/keysdeny
Cross-org requestdeny
middlewareaudit-loggedno UI-only checks

Permissions by role

CapabilityOwnerAdminMemberViewer
Read keys, members, usage
Included
Included
Included
Included
Create + use virtual keyssk-nemo-... for LLM traffic
Included
Included
Included
Not available
Update org settingsBranding, data policy, callbacks
Included
Included
Not available
Not available
Invite + remove members
Included
Included
Not available
Not available
Configure guardrails + prompts
Included
Included
Not available
Not available
View audit trail
Included
Included
Not available
Not available
Export usage CSV
Included
Included
Not available
Not available
Manage billing + planStripe portal, plan change, cancel
Included
Not available
Not available
Not available
Delete the organization
Included
Not available
Not available
Not available
IncludedNot availableNot applicablenSourced footnote below
Tenant Isolation

The same UUID flows through every layer

organization_id is the same value in your Bearer key, in the Frontend session, in Nemo Backend, in the in-process Nemo Intelligent Proxy Router, and in every nemo.* table. There is no mapping table to drift, no sync layer to compromise.

RLS on everything

Cross-tenant queries return zero rows — by the database, not the app

Postgres Row-Level Security policies are scoped by organization_id on every nemo.* table. A bug in application code cannot leak data because the database refuses to return it in the first place.

  • RLS enabled on all 22 nemo.* tables (Owner, Admin, Member, Viewer policies)
  • Service role bypasses RLS only inside server-side API routes
  • No `USING (true)` policies anywhere in the schema
  • Org switch invalidates every TanStack Query cache key
psql · cross-tenant probe

RLS in action

Org A reads Org A keys14 rows
Org A reads Org B keys0 rows
Service role readall rows
USING (true) policies0
Tables w/ RLS enabled22 / 22
Cross-tenant denials (24h)0
Postgres RLSorganization_idsame-UUID
Single-org-per-user enforced at the database is the detail that closed our security review. We could not engineer a way to leak across tenants because the schema refused to return rows.

Director of Engineering

Series-B health-tech, ~80 engineers

FAQ

Common team questions

Invite your team

Bring your whole engineering org — no per-seat fee

Sign up, create the org, invite by email. Roles, RLS, and audit logging are on by default. The dashboard is identical at every tier.