<!-- Markdown mirror. Canonical: https://empryo.com/docs/providers/subscriptions -->

# Subscriptions

> Sign in to ChatGPT, Copilot, Cursor, Devin, Gemini, Grok, Kimi and more from Empryo with no add-on. One /login picker, credentials in your keychain.

If you already pay for a plan like ChatGPT Plus, you can use it in Empryo instead of buying API credit. Run `/login`, pick your account, and sign in. You do not need to install anything else.

Empryo stores the sign-in in your system keychain and renews it when it expires.

## Accounts you can sign in to

Most accounts sign in through your browser or with a device code (a short code you type on a web page). A few ask you to paste a key instead.

These accounts all appear under one provider, called **Subscriptions**:

| Account | How you sign in | Model ids |
|---------|-----------------|-----------|
| ChatGPT Codex | browser | `subscriptions/gpt-*` |
| ChatGPT Codex (device code) | device code | `subscriptions/gpt-*` |
| Grok (SuperGrok / X Premium) | browser | `subscriptions/grok-*` |
| Grok (device code) | device code | `subscriptions/grok-*` |
| Cursor | browser | `subscriptions/cursor/*` |
| Devin (Cognition) | browser | `subscriptions/devin/*` |
| Gemini CLI (Google Cloud Code Assist) | browser | `subscriptions/google-gemini-cli/*` |
| Antigravity (Google) | browser | `subscriptions/google-antigravity/*` |
| Kimi Code (Moonshot) | device code | `subscriptions/kimi-code/*` |
| Fire Pass (Fireworks) | paste a key | `subscriptions/*` |

These accounts use the same `/login` list but keep their own provider, because each has its own models and billing:

| Account | How you sign in | Model ids |
|---------|-----------------|-----------|
| GitHub Copilot | device code | `copilot/*` |
| GitHub Copilot (Enterprise) | device code on your company's GitHub | `copilot/*` |
| OpenRouter | browser, which creates a key for you | `openrouter/*` |
| Ollama Cloud | paste a key | `ollama-cloud/*` |
| LLM Gateway, LLM Gateway DevPass | browser, which creates a key for you | `llmgateway/*` |
| Kilo Gateway | device code | `kilo/*` |
| Z.AI Coding Plan | browser, then paste the final page's address back | `zai-coding-plan/*` |
| Alibaba Coding Plan | paste a key | `alibaba-coding-plan/*` |
| Alibaba Token Plan | paste a key | `alibaba-token-plan/*` |
| Xiaomi MiMo | paste a key | `xiaomi/*` |

Z.AI is the only sign-in that cannot finish on its own. The browser ends on a web page instead of returning to Empryo. Copy that page's address and paste it into Empryo when asked.

Some accounts offer the same base models. For example, Gemini CLI and Antigravity both serve `gemini-*` models. To keep them apart, their model ids include the account name (`google-gemini-cli/…`, `google-antigravity/…`). Cursor and Devin work the same way. This way you always know which account pays for a turn.

> **Warning:**
> **Use at your own risk.** A subscription sign-in is meant for the vendor's own app. Empryo is not affiliated with any of these vendors, and none of them has approved this use.

> Whether your plan allows it is between you and the vendor. Read your subscription terms before you sign in. Rate limits, revoked sign-ins, and account suspension are all possible. Empryo cannot restore a suspended account.

## Signing in

Run `/login` in the terminal UI or the desktop app. The list shows every account you can sign in to, marks the ones you are already signed in to, and starts the sign-in you pick.

```
Sign in
  ChatGPT Codex
  ChatGPT Codex (device code)
  Cursor
  Devin (Cognition)
  GitHub Copilot                 device code
  GitHub Copilot (Enterprise)    ghe.example.com
  Grok (SuperGrok / X Premium)
  Grok (device code)
  Gemini CLI
  Antigravity
  Kimi Code                      device code
  Fire Pass                      paste key
  OpenRouter
  Ollama Cloud                   paste key
  LLM Gateway                    signed in
  Kilo Gateway                   device code
  Z.AI Coding Plan
  Alibaba Coding Plan            paste key
  Alibaba Token Plan             paste key
  Xiaomi MiMo                    paste key
```

Each row shows how the sign-in works and which account you are on. A Copilot Enterprise row also shows the GitHub host, so you can tell a company account from a personal one.

To skip the list, add the account name:

```bash
/login codex           # ChatGPT, browser
/login codex-device    # ChatGPT, device code
/login grok            # Grok, browser
/login grok-device     # Grok, device code
/login cursor          # Cursor, browser
/login devin           # Devin, browser
/login google-gemini-cli   # Gemini CLI (Google Cloud Code Assist)
/login google-antigravity  # Antigravity (Google)
/login kimi-code       # Kimi Code, device code
/login copilot         # GitHub Copilot
/login copilot-enterprise  # GitHub Copilot on a GHE host
/login openrouter      # OpenRouter, browser
/login firepass        # Fire Pass, masked key entry, no browser
/login ollama-cloud    # Ollama Cloud, masked key entry
/login kilo            # Kilo Gateway, device code
/login zai-coding-plan # Z.AI GLM coding plan, browser then paste the redirect
/login alibaba-coding-plan # Qwen coding plan, masked key entry
/login alibaba-token-plan  # Qwen token plan, masked key entry
/login xiaomi          # Xiaomi MiMo, masked key entry
```

Brand names work too: `/login chatgpt` goes to ChatGPT Codex, `/login xai-oauth` to Grok, `/login zai` and `/login glm` to the Z.AI coding plan, and `/login qwen` to the Alibaba coding plan.

For accounts marked "masked key entry", you paste the key into a hidden field (the keys panel in the terminal UI, a password field in the desktop app). You never type it on the command line. Alibaba and Xiaomi sell the same plan in several regions. Empryo tests your key and finds the right region for you.

You can also sign in without a UI:

```bash
empryo --headless --login codex
empryo --headless --login codex --no-browser
```

`--no-browser` prints the sign-in address instead of opening a browser. This helps when you are connected to a machine over SSH. For the paste-a-key accounts, put the key after the name: `empryo --headless --login firepass <key>`.

If you pick an account you are already signed in to, Empryo asks before it continues. Signing in again replaces the stored sign-in.

### When the browser cannot reach Empryo

Browser sign-ins send you back to a small local web server that Empryo starts on your machine.

- **ChatGPT** must use port 1455, because OpenAI only accepts that address. If something else is using port 1455, Empryo tells you before it opens the browser.

In that case, or when your browser is on another computer, use the device code instead:

```bash
/login codex-device
```

Empryo shows a code. Open `auth.openai.com/codex/device`, type the code, and you are done. No local port is used.

### Remote machines and servers

Browser sign-ins need a browser on the same machine as Empryo. Over SSH, in a container, or on a server with no desktop, your browser is somewhere else. You have three options, easiest first:

1. **Use a device code.** ChatGPT (`codex-device`), Grok (`grok-device`), Copilot, Copilot Enterprise, Kimi Code, and Kilo work from any browser on any machine.
2. **Forward the port.** Run `ssh -L 1455:localhost:1455 host` for ChatGPT (54549 for OpenRouter). Then run `/login` on the remote machine and open the printed address on your own computer.
3. **Paste a key.** Fire Pass, Ollama Cloud, and the coding plans accept a key directly.

Add `--no-browser` on machines that have no default browser.

Empryo stores sign-ins in your system's secret store: the keychain on macOS, the Windows credential protection on Windows, and the secret service on Linux desktops. Most Linux servers have no secret service. There, Empryo uses a file under the config folder that only your user can read. `/keys` shows where each key is stored.

## Where the models show up

Every signed-in account appears under the **Subscriptions** provider in the model picker, grouped by account. Model ids look like `subscriptions/gpt-5.6-sol`, `subscriptions/grok-4.2`, or `subscriptions/cursor/composer`. To switch plans, you just pick a different model.

Empryo asks each vendor which models your account can use. If the vendor does not answer, it falls back to [models.dev](https://models.dev) data, and then to a built-in list.

When you sign out of an account, its models leave the picker.

> **Note:**
> If you are not signed in to anything, the Subscriptions row still appears and reads `not signed in`. Press Enter on it to open the sign-in list.

## Things to know

- The ChatGPT subscription only supports streamed replies. Anything that needs a non-streamed reply fails with a clear error.

## Signing out

Run `/login`, pick the account, and choose **Sign out**. This deletes the stored sign-in from your machine. It does not change your account with the vendor. To sign back in, follow the same steps as the first time.

## Subscriptions, proxy, or an API key

| | Subscriptions | [Proxy](/docs/providers/proxy) | API key |
|---|---|---|---|
| Install | nothing | `empryo addon install proxy` | nothing |
| Covers | ChatGPT, Copilot, Grok, Cursor, Devin, Gemini, and more | Claude, ChatGPT, Gemini, Grok | every provider |
| Where the credential lives | your keychain | the proxy's own files | your keychain |
| Accounts per provider | several, with automatic switching | several | one key, or several for [custom providers](/docs/providers/custom#several-accounts-on-one-provider) |
| You pay with | your plan | your plan | credit, per token |
| Usage display | plan limits | [plan limits](/docs/providers/proxy) | [spend per token](/docs/concepts/cost-tracking) |

You can use more than one. They are separate providers with separate sign-ins, and the model id tells you which one runs the turn.

## More than one account

Run `/login` again and pick **Add another account**. Both accounts stay signed in, and the list marks the one that will pay for the next turn.

One email address can have more than one plan, for example a Team seat and a personal Max plan. Empryo keeps them as two separate accounts.

**When a plan runs out, Empryo switches to the next account.** The used-up account waits until its limit resets. The terminal shows which account took over, next to the plan meter.

- Only a used-up plan causes a switch. A short "too many requests" error is waited out on the same account.
- Limits are tracked per model family. Using up the weekly limit for one model family does not stop the account from serving other models.

Empryo also switches before sending a request if it already knows the current plan is used up. That way a long turn does not fail halfway through.

You can pick an account by hand at any time from `/login`. The same list lets you switch, add, and sign out of accounts.

## How much of your plan is left

Empryo asks each vendor for your usage, so the numbers match what the vendor's own app shows. That includes the 5-hour limit, the weekly limit, and per-model weekly limits where the plan has them, each with its reset time.

| Account | What the meter shows | Unit |
|---------|----------------------|------|
| ChatGPT Codex | 5-hour and weekly limits | percent |
| GitHub Copilot | premium requests, chat, and completions against your seat's allowance | requests |
| OpenRouter | spend against the key's credit limit | US dollars |

Keep two things in mind:

- **Copilot** counts premium requests, not tokens. If your seat allows extra paid usage, it keeps working past the allowance and GitHub bills you for it. Empryo shows how many extra requests you used and estimates the cost from GitHub's published price per request. GitHub does not report that dollar amount, so Empryo labels it as an estimate. If the price changes, set `EMPRYO_COPILOT_PREMIUM_USD` to the new rate.
- **OpenRouter** reports your total spend and, if the key has one, its credit limit. For a key with no limit, Empryo shows the spend without a progress bar.

When you use a subscription model, the status bar shows your plan meter in both the terminal and the desktop app. `/usage` lists every limit for every account. The desktop app's usage page shows one card per plan.

The per-token costs Empryo shows for subscription models are **estimates** based on token counts and models.dev prices. They are not what you are billed. Your plan meter is the number that matters.

## Troubleshooting

**Port 1455 is in use**

Only ChatGPT needs that exact port. Close whatever is using it, or run `/login codex-device` instead.

**The browser opened but nothing came back**

Empryo listens on both IPv4 and IPv6 for the return address. If the page still hangs, close it and use a device-code sign-in instead.

**Signed in, but no models**

Open `/login` and check the account. A sign-in that has passed its renewal window can still look signed in until the next renewal fails. Sign in again.

**Usage credits are required for long context requests**

This comes from a model using the 1M-token context option on a subscription. Empryo does not request that option on subscription models, so pick a model with a native 1M-token window instead.

**Workspace is not authorized in this region**

This happens with a company ChatGPT workspace tied to a region. Sign in again to fix it.

## Related

- [Proxy](/docs/providers/proxy): an optional add-on that runs subscriptions through a local relay
- [GitHub Copilot](/docs/providers/copilot): setup and usage limits for Copilot
- [Providers overview](/docs/providers/overview): every way to connect a model
- [Cost tracking](/docs/concepts/cost-tracking): how per-token spending is shown