Guide

Plans

Pool your team's ChatGPT and Claude plans beside your API keys. Every tool pointed at the gateway rotates across them, and you watch every plan's limits live.

Part of Pro. Adding a plan needs the Pro plan (upgrade). A 402 with code pro_required means the organization is not on Pro yet.

What a plan is

A plan is a ChatGPT (Plus, Pro, Team or Enterprise seat) or Claude (Pro, Max or Team seat) sign-in, added as one account in your organization's pool. Requests for that provider's models can then run on the plan's allowance instead of an API key. Each plan has a 5-hour and a weekly usage window; when one runs out, traffic moves to your next plan or key and the plan comes back on its own after the reset.

Add plans in the dashboard

Open Settings › Connections › Plans.
ChatGPT plan: sign in through the browser (the tab ends on a localhost:1455 page that does not load; paste its address back) or import the sign-in Codex already holds.
Claude plan: approve on claude.ai. Depending on the deployment, the sign-in either comes straight back here or ends on a page with a one-time code you paste into the form; you can also import the sign-in Claude Code already holds on this machine. It appears only where the deployment has Claude plans enabled.
Repeat for every account. Each plan shows as a card with its live limits.

Or let your coding agent do it

Paste this into your coding agent. It uses your organization key (EXPLABS_API_KEY), imports Codex sign-ins with your permission, and hands you the sign-in links it cannot open itself.

Plans setup prompt

I pasted this into you myself, so add my ChatGPT and Claude plans to the Plans pool on my
Experiential Labs gateway. Every tool I point at the gateway then rotates across these plans and my API keys, and I can watch the limits at https://platform.experientiallabs.ai/settings/connections#plans.
This is my consent to wire it up. Plans are part of the Pro plan: a 402 with code
pro_required means my org needs Pro at https://platform.experientiallabs.ai/credits first.

Use my Experiential Labs org key as the bearer token on every call below. It is a
secret: read it from the EXPLABS_API_KEY environment variable and never print it in
full. If it is not set, ask me for it (I can mint one at https://platform.experientiallabs.ai/api-keys).

First find my org id and the accounts it already has:
  GET https://api.experientiallabs.ai/api/whoami  with header Authorization: Bearer $EXPLABS_API_KEY
  Capture org_id, then GET https://api.experientiallabs.ai/api/orgs/<org_id>/provider-connections.
  Rows whose credential_kind is chatgpt_plan or claude_plan are plans. Pick a new
  setup_alias for each plan you add (chatgpt-1, chatgpt-2, claude-1, ...), unused
  across ALL of my accounts.

Add my ChatGPT plan (the Plus, Pro, Team or Enterprise seat I use Codex with):
1. Ask me which way I prefer, then do exactly one:
   a. IMPORT (fastest, but it moves my sign-in): if this machine's Codex is signed in to
      that account, read ~/.codex/auth.json in full (the whole file is the auth_json value):
      POST https://api.experientiallabs.ai/api/orgs/<org_id>/provider-connections/openai/plans/import
      with body {"auth_json": "<the file's contents as a string>", "setup_alias": "chatgpt-<n>"}
      Tell me clearly: my local Codex is now signed out and must run 'codex login' again.
   b. BROWSER (keeps both signed in): POST https://api.experientiallabs.ai/api/orgs/<org_id>/provider-connections/openai/plans/sign-in
      with body {"setup_alias": "chatgpt-<n>"} and give me the authorize_url from the response.
      I open it, approve on the ChatGPT account, and my browser then lands on a
      localhost:1455 page that does not load. I paste you that page's full address, and you
      POST https://api.experientiallabs.ai/api/orgs/<org_id>/provider-connections/openai/plans/sign-in/complete
      with body {"state": "<state from the sign-in response>", "callback": "<the address I pasted>",
            "setup_alias": "chatgpt-<n>"}

Add my Claude plan (the Pro, Max or Team seat I use Claude with):
0. First GET https://api.experientiallabs.ai/api/orgs/<org_id>/provider-connections/anthropic/plans. If "available" is false, Claude plans are not
   enabled here: skip this and tell me so. Otherwise remember "completion" for below:
   "paste" means each sign-in ends on a page with a one-time code I paste back to you;
   "redirect" means it finishes on its own.
1. Ask me which way I prefer, then do exactly one:
   a. IMPORT (fastest, but it moves my sign-in, and ONLY when completion is "paste"): if
      this machine's Claude Code is signed in to that account, read
      ~/.claude/.credentials.json and POST its full contents to
      https://api.experientiallabs.ai/api/orgs/<org_id>/provider-connections/anthropic/plans/import
      body {"auth_json": "<the file's contents as a string>", "setup_alias": "claude-<n>"}
      Tell me clearly: my local Claude Code is now signed out and must sign in again.
      On macOS the file may live in the Keychain instead; if it does, use the browser way.
   b. BROWSER (keeps both signed in): POST https://api.experientiallabs.ai/api/orgs/<org_id>/provider-connections/anthropic/plans/sign-in
      body {"setup_alias": "claude-<n>"} and give me the authorize_url from the response.
      I open it in a browser where I am signed in to claude.ai and approve.
      - If completion is "redirect", it finishes on its own and lands on my Plans page at
        https://platform.experientiallabs.ai/settings/connections#plans.
      - If completion is "paste", the page ends with a one-time code. I paste it to you,
        and you POST https://api.experientiallabs.ai/api/orgs/<org_id>/provider-connections/anthropic/plans/sign-in/complete
        body {"state": "<state from the sign-in response>", "callback": "<the code I pasted>",
              "setup_alias": "claude-<n>"}

After each add, report from the response: setup_alias, plan.label, plan.plan_type, and the
used_percent of plan.primary and plan.secondary if present. A 409 means that sign-in
expired or was already used: start it again, do not retry the completion. Never print a
token, the credentials file contents, or my org key.

Nothing else to configure: any harness (Claude Code, Codex, OpenCode, Cursor, ...) pointed
at https://api.experientiallabs.ai/v1 with my key uses the plans. One
limitation to know: a request that sets an output ceiling (max_tokens) skips ChatGPT plan
rungs, so that case falls to my API keys.

If you cannot do this, tell me and I will add the plan at https://platform.experientiallabs.ai/settings/connections#plans.

Use them from any harness

There is nothing plan-specific to configure. Point your tool at the gateway with your key as usual; requests for OpenAI and Anthropic models rotate across your plans and keys.

Point a harness at the gateway

# Claude Code (Anthropic Messages)
export ANTHROPIC_BASE_URL="https://api.experientiallabs.ai"
export ANTHROPIC_API_KEY="xpl_..."
claude

# Codex, OpenCode, Cursor, or any OpenAI-compatible tool
export OPENAI_BASE_URL="https://api.experientiallabs.ai/v1"
export OPENAI_API_KEY="xpl_..."

See Coding agents for per-tool setup.

Rotation and live limits

Each plan card shows its 5-hour and weekly windows and when each resets, updating every minute while the page is open.
In rotation means the pool may route to the plan; Resting until reset means a window is used up and traffic goes elsewhere until it resets.
The pool's order and failover settings are the same as for API keys.

Good to know

Importing a Codex sign-in hands it over: run codex login again for Codex itself.
A request that sets an output ceiling (max_tokens) skips ChatGPT plans, which do not accept one.
A ChatGPT plan serves GPT-5 family models; a Claude plan serves Claude models.
Tokens are stored encrypted and never returned; responses show a masked email only.
Using a plan through a gateway is subject to the provider's terms for that plan.

API

Every call takes your organization key as a bearer token. Adding a plan needs Pro; reading and disconnecting never do.

Endpoint	Purpose
GET /api/orgs/{org_id}/provider-connections/{openai\|anthropic}/plans	Whether that provider's plans can be added on this deployment.
POST …/{openai\|anthropic}/plans/sign-in	Start a browser sign-in: returns authorize_url and state.
POST …/{openai\|anthropic}/plans/sign-in/complete	Finish it with the state and the address the browser landed on.
POST …/openai/plans/import	Import a Codex sign-in (the contents of ~/.codex/auth.json).
POST …/{openai\|anthropic}/plans/{setup_alias}/refresh-usage	Re-read one plan's 5-hour and weekly windows now.
GET /api/orgs/{org_id}/provider-connections/accounts/usage	Every account, plans included, with pool state and usage.
DELETE /api/orgs/{org_id}/provider-connections/{provider}?setup_alias=…	Disconnect one plan; its stored sign-in is deleted.

PreviousThe waterfall NextAdding models