---
title: Accounts and usage
description: Use several accounts per provider, choose how Lookout routes between them, and see what each plan has left.
canonical_url: https://lookout.itoowasinarcadia.com/docs/usage
type: guide
section: Use Lookout
last_updated: 2026-10-22
related:
  - https://lookout.itoowasinarcadia.com/docs/models
  - https://lookout.itoowasinarcadia.com/docs/account
---

> Every page of these docs: https://lookout.itoowasinarcadia.com/llms.txt

# Accounts and usage

Use several accounts per provider, choose how Lookout routes between them, and see what each plan has left.

Lookout reads each plan's limits from its provider and shows what is left. With more than one account on a provider,
you choose how requests spread across them. **Settings › Usage** counts tokens and turns; it shows no prices.

## Add another account

1. Open **Settings › Providers** and click the provider's row.
2. Under **Accounts**, click **Add account**.
3. Sign in with the other account, the same way as the first ([Connect a provider](https://lookout.itoowasinarcadia.com/docs/models#connect)).

A provider's sign-in page signs in whoever your browser is already signed in as, so Add account doesn't open it by
itself. Click **Open sign-in** if your browser is signed in to the account to add, or **Copy link for a private
window** and open it in a private window (or another browser profile), then sign in there.

Most providers take up to fifteen accounts; Cognition's Devin takes one ([Providers](https://lookout.itoowasinarcadia.com/docs/models#providers)). The menu at
the end of an account's row has **Rename**, **Sign out**, **Sign in again** once its sign-in expires (or ends within
three days), and, with two or
more accounts under One account or Failover, **Use for requests**, and under Failover or Balance **Exclude from pool**
([below](https://lookout.itoowasinarcadia.com/docs/usage#exclude)). **Rename** gives the account a name of your own,
such as **Work**: the row, the chat's account and the chat's notices use it, with the account's address beside it in
the row. Save an empty name to go back to the address.

**Sign in again** renews that account, so pick the same account on the provider's page. If you sign in as another
one, Lookout saves nothing and names the account to sign in as; add the other one with **Add account**.

## Choose how requests use your accounts

With two or more accounts, the provider's row shows **Use**:

| Option | Requests go to |
|---|---|
| **One account** | The account marked **In use**. While it can't take them (its limit reached, its sign-in refused), the account whose allowance resets soonest among those with room does. A chat already working there stays while its cache is warm and that account has room, and returns when its cache goes cold. **Use for requests** in another account's menu moves them there at once. |
| **Failover** | The account marked **Primary** until it has the percent you set in **Switch at** left (5 to start), then the account whose allowance resets soonest. New chats return to the Primary once it has room again; a chat already working on another account stays there while it has room. **Use for requests** makes an account the Primary. |
| **Balance** | The account whose allowance resets soonest, among those with room (a new chat skips one that is nearly spent while another isn't), so less of it resets unused. A chat whose prompt cache is warm stays on its account until that account's limit is reached, since a move reads the whole chat again; **Switch at** steers only new chats and chats idle past the cache's lifetime. The exception is the first account you signed in with, the one kept for your own use: while it is in the pool, a chat on it moves at **Switch at** too. |

Under Failover and Balance, a request that fails on one account before anything comes back moves to another (a short
pause the provider asks for is waited out on the same account, a server error is retried there twice before the chat
moves, and a dropped connection never moves it, since a move reads its whole prompt again). A summary of a long chat
runs on the account the chat is on while that account can take it, even when it is nearly spent, since the summary
reads the chat from that account's cache; the chat moves after it, with the shorter context. Under Failover, **Answering now** marks
the account requests go to while it isn't the Primary; Balance marks none, since its pick changes request by request.
Under One account, a request the account in use can't
take goes to the account with room the same way, and **Answering now** marks that account; nothing else changes, and
a chat whose cache is warm there stays until it goes cold, when its turns go back to the account in use. A limit reached partway through an answer stops that turn;
the next one moves. With one account left, the provider goes back to One account unless you chose the option yourself.
With two or more accounts and no option chosen, a provider uses Balance. The option, **Switch at** and which accounts
are excluded follow your Lookout account: every machine signed in to it routes the same way.

### Exclude an account from the pool

**Exclude from pool** in an account's menu, under Failover or Balance, keeps automatic switching off that account:
neither sends a request there on its own, and a chat working there moves to another account at its next request. The
row reads **Excluded**, and **Include in pool** brings it back. A chat you picked that account for, and the Primary,
still use it (the Primary's menu offers no Exclude). Under One account the mark doesn't apply: when the selected account
runs out, requests go to the account with room that resets soonest, an excluded one too (the option's hint says so).
With only excluded or spent accounts left, a chat waits for the
first account in the pool to reset, as when every account is spent, and every surface that counts the pool says so:
an excluded account never counts toward **1 of 4 open**, the usage mark's level or **Limit reached**, and its room
doesn't end the wait. Its segment and column come last, faint, and in **Settings › Usage** its line sits under **Not in
the pool**. When the pool is spent and an excluded account has room, the row says so, such as **Limit reached; Personal
is out of the pool**, and the usage card says it under its head. When an account in the pool has room again, one
waiting chat goes first, and the rest once it got an answer.

Under Failover and Balance, switching the option or the Primary changes where new chats go; a chat whose prompt cache is still warm (it
worked within the provider's cache lifetime, an hour on Claude and 5 minutes for a Claude subagent) stays on its account while that account can take it (under Failover, until **Switch at**), so it
doesn't re-read the whole chat on another one. Restarting Lookout, or an update, keeps that too, and so do
`lookout exec` and `lookout resume` from one run to the next.

## Choose the account a chat uses

When the chat's model comes from a provider with two or more accounts, the model menu has an **Account** row under
the chat's model: **Automatic** (the provider's **Use** choice decides), or the account the chat chose. Open it to pick
another. Each account that can take requests says what it has left on its tightest window. Accounts at their limit are
dimmed and say when they are back, soonest first; two or more fold into one row, such as **5 at their limit** with
**First back in 1d 2h**, which opens them. **Manage accounts** opens the provider in Settings.

Once a chat chose an account, the status row under the message box names it too, and opens the same menu. On
**Automatic** it shows nothing there.

- A chosen account takes the chat's next turn and its subagents' requests to that provider ([a subagent on another model](https://lookout.itoowasinarcadia.com/docs/subagents#model) uses that model's provider). A turn already running stays on its account.
- The chat goes to another account while its own is spent or refused, and comes back once it has room again.
- **Automatic** gives the chat back to the provider's **Use** choice.

The card under the [usage mark](https://lookout.itoowasinarcadia.com/docs/usage#usage-mark) beside it lights the chat's account: the one you chose while
it can take the chat's requests, else the one the chat's prompt cache is warm on, else, under One account or Failover,
the one requests go to. Under Balance a new chat lights none, nor does one idle past its cache's lifetime or switched to
another model since: where its next request goes isn't known until it is sent. The light moves only once the chat has
stayed on its new account for a moment, so a quick back and forth never shows.

When a turn moves to another account partway, the chat says **Switched to** that account where it moved, and the
turn's footer names both, such as **via ada@example.com, then bo@example.com**.

## The usage mark under the message box

The provider's mark at the end of the status row stays quiet while the chat can keep working on its model. It turns
amber with a dot when every open account is at 15% or less, red with **Back in 1h 15m** when no account can take the
chat's next request (**Limit reached** when no reset is known), and says **Sign-in expired** when every account needs
a new sign-in.

Hover it for the plan's windows. With several accounts the card is one grid: a row per window (**5-hour**, **Weekly**,
and the chat's model's own window when that binds first), a column per account, **1 of 4 open** at the top, and at a
row's end when the next account that window closed comes back. When the pool runs out before the window that binds it
resets, the [run-out line](https://lookout.itoowasinarcadia.com/docs/usage#usage-page) sits under the head. The chat's account is the lit column
([which one](https://lookout.itoowasinarcadia.com/docs/usage#chat-account)). A window that can't be used before its account is back is drawn faint.
Point at a column to read that account's address, plan and values; click it to open the account in **Settings ›
Usage**.

## Read a plan's meters

Open a provider's row to see each account's plan windows (**5-hour**, **Daily**, **Weekly** or **Monthly**, as the
provider reports them), each with what is left and when it resets. A plan that also limits one model on its own,
such as a Claude plan's weekly limit for Fable, shows that window after the plan's, named for the model (**Fable
weekly**); it limits only that model, and under Failover or Balance only that model's requests move to another account.
The row's header shows the window with the least left, such as **Weekly 52% left**; with several accounts it says how
many can take a request and when the next one comes back instead, such as **1 of 4 open** and **1 back in 1h 15m**, as
**Settings › Usage** does. Closed, the row shows a red alert mark once every account's plan is spent. A plan read more
than a minute ago is read again as the page opens, and its row updates by itself when the answer comes. The refresh
button beside the **Providers** title reads every plan again.

| You see | It means |
|---|---|
| **52% left** | What is left of this window. At 15% or less it turns to a warning color. |
| **<1% left** | Almost spent. |
| **Limit reached** | Spent until the reset shown under it. |
| A sentence in red, such as **This Claude account is on hold** | The provider stopped this account for a reason of its own, with no reset to wait for. The sentence says what to do. |
| **Not started** | The window hasn't started yet, so all of it is left. |
| **Reset, updating** | The window reset since the last reading; the next reading replaces it. |
| **Rate limited for a moment** | The provider asked for a pause. The plan isn't spent. |
| **Usage appears after your next request.** | This provider reports usage only alongside its replies. |
| **No active plan** | The provider says this account has no plan any more: it was canceled, it expired, or the account never had one. Hover for the provider's reason. Its models don't run until you renew the plan (**Renew plan** opens the provider's page when Lookout knows it) or remove the account. |
| **Refused by** the provider, such as **Refused by Anthropic** | The provider refused this account a request (HTTP 403) that another of your accounts then served: its plan ended or its access is off. Hover for the provider's words. **Sign in again** clears it, and so does a usage read that works; **Check plan** opens the provider's plan page when Lookout knows it. |
| What the provider answered, such as **Z.ai answered 500**, or **Usage last read** | The last reading failed or brought nothing new, so the numbers shown are older. Hover for the provider's whole answer. |
| An amount, such as **USD 4.73** | A prepaid balance, shown in place of windows. |
| **Extra usage on** | The plan's paid extra usage is turned on, with what it used when the provider says. **In use**: replies are drawing on it now ([when a plan runs out](https://lookout.itoowasinarcadia.com/docs/usage#plan-runs-out)). |
| **Budget left USD 99.58** | What an API key billed per token still has of the budget you set, by Lookout's own count on this device. It is not the provider's remaining credit: a normal key cannot read that. At the budget the account stops taking requests until you raise it. A key the provider has refused for credit shows that sentence instead, even when budget left is still positive. |

A badge beside the account, such as **ChatGPT Plus** or **Claude Max**, is the plan's name when the provider reports
it. On Anthropic's row an API key's badge says **API key**.

## When a plan runs out

- The model menu says so on that provider's models, for example **Weekly limit used up, resets in 3d 2h**. They stay
  pickable: the window resets, and another account may have room.
- A model whose own limit is used up while the plan has room, such as **Fable weekly limit used up, resets in 3d 1h**,
  says so on that model alone: in the model menu, on its row under **Models** in **Settings › Providers**, and as a
  row of its own in the message box's usage card; **Continue on** doesn't offer it. The provider's other models run
  as usual. With several accounts it says so only once the limit is used up on all of them.
- Requests move to an account with room left, under any **Use** choice. Under One account a chat warm on the other
  account stays there until its cache goes cold, then its turns go back to the account in use.
- Each Claude account is its own sign-in, whatever Claude Code is signed in to: with several added, **Continue on**
  and Failover or Balance move the chat to whichever has room.
- A Claude plan with extra usage turned on (in claude.ai's settings) keeps answering once it is spent, and Anthropic
  bills that usage. Lookout sends such an account nothing past its plan unless **Use extra usage once every plan is
  spent** is on in Anthropic's row in **Settings › Providers**, and then only once no account has plan room. If a
  reply was served from extra usage while it is off, Lookout stops using that account until its limit resets and says
  so once.
- When the account a turn ran on is spent (or needs a new sign-in) and another of the provider's accounts has room,
  the notice offers **Continue on** that account: the chat moves there and the turn picks back up. Requests already
  move by themselves, so this shows when an account ran out partway through an answer.
- When no account has room, the turn stops on a quiet notice that says which limit is used up (the
  provider's **5-hour** or **weekly** limit when the provider names it, else the model's plan limit) and, when the
  provider gave one, the reset time: with several accounts, the soonest any of them takes requests again, which is
  also when a chat or agent waiting at that limit goes on. **Continue on** under that notice names the best move,
  **Continue on MODEL** (the chat's fallback models first); its chevron lists every model the chat can run now with
  what its plan has left, never one of the spent plan, and one billed per token reads **Per token**. **Wait for the
  reset** waits for it instead ([Try again after an error](https://lookout.itoowasinarcadia.com/docs/chats#retry)).
- `lookout exec` exits with code 3.

## Keep sign-ins in sync across devices

Signed in to your Lookout account, a provider you connect on one device connects on your other devices too, and
signing out of a synced account signs it out on all of them. Without a Lookout account, each sign-in stays on the
device it was made on. OpenCode's free tier is always set per device.

An account synced to all your devices says nothing more. Otherwise its row says where its sign-in lives:

| Label | Meaning |
|---|---|
| **Syncing** | Being synced with your account. |
| **This device only** | Stays on this device. Hover for why. |
| **From environment** | An environment variable on this device supplies it, so it stays here. Unset the variable to sign out. |
| **Sync needs you** | This device and your account hold different sign-ins, or the sync failed. When they differ, the provider's row offers a choice. |

**Sync needs you** offers **Keep this device's sign-in** or **Use your account's sign-in**. A sign-in that came from
another Lookout account offers **Add it to this account**, **Use this account's sign-in** or **Keep it on this device
only**.

When your Lookout account doesn't answer for a while, a notice above the providers says sync is paused and why. It
says **Trying again now** only while Lookout waits on an answer, otherwise when the next try is, and it names any
sign-in you saved here that hasn't reached your account yet. **Try now** tries at once. The notice clears by itself on
the next try that gets through.

On a machine without the app, `lookout providers` lists this machine's providers and settles the same choices.
PROVIDER is a provider's name, in quotes when it has a space:

```sh
lookout providers                      # this machine's providers
lookout providers sync                 # read your account now
lookout providers use-account PROVIDER # use your account's sign-in
lookout providers keep PROVIDER        # put this machine's sign-in in your account
lookout providers keep-local PROVIDER  # keep this machine's sign-in here only
```

## See your usage

Open **Settings › Usage**, or **Usage** in the account menu at the foot of the sidebar. A mark beside **Usage** there
means a provider cannot answer at all: a red alert mark when every account is at its limit, an amber dot when every
account needs a new sign-in.

**Limits** shows what each plan has left, one row per provider however many accounts it has. Anthropic is one row
for its Claude plans and its API key:

- The row's bar has a segment per account: a red one is at its limit (a faint fill on it is what comes back with it,
  such as its week behind a spent 5-hour), a dashed one needs a new sign-in, and under One account or Failover the
  bright one is the account requests go to. Past eight accounts the segments go open ones first, then the spent, then
  the rest; [excluded](https://lookout.itoowasinarcadia.com/docs/usage#exclude) accounts come last, faint. Point at a segment to see that account's windows.
- Beside the bar, one account says what it has left, such as **Weekly 52% left**. Several say how many can take a
  request and when the next one comes back, such as **1 of 4 open** and **1 back in 1h 15m** (or, when every one is
  nearly spent and none is at its limit, when the first resets).
- **Attention** comes first, only when something needs you: a provider at its limit (with when it resets), an account
  to sign in again (**Sign in again** opens its sign-in here), a sign-in ending within three days, or every account
  nearly spent. An account at its limit while another one answers stays in **Plans**: requests have already moved, and
  its window reopens by itself.
- **Balances** lists keys that report money instead of windows: a prepaid balance the provider reports, or budget
  left on a key Lookout meters itself. Budget left is not the provider's remaining credit. An Anthropic API key beside
  Claude plans is a line of Anthropic's row instead, named **API key**, with its budget left or what it spent, to the
  cent.
- Click a row to see one line per account and its windows, with what is left and when it resets (**in 3h 30m** today,
  **Fri 11:48** this week); a used-up window says **Spent** and when it comes back. A model's own limit (a Claude
  plan's **Fable weekly**) gets a line under an account only while it runs out before the plan does. A window that
  can't be used before its account comes back, such as a 5-hour under a spent week, is drawn faint. A dot marks each
  account a chat is working on (its name's tooltip says **In use by 2 chats**), and the bright name is the account
  requests go to. Excluded accounts come after the rest under **Not in the pool**, their bars faint, so **1 of 3 open**
  counts the lines above them. Past eight accounts the list shows the first six (and the bright one); **Show more**
  lists the rest.
  **Manage** opens the provider in **Settings › Providers**. The refresh button beside the title reads every account
  again.
- Above an open row's accounts, a line such as **At this pace the weekly limit runs out in about 5h 20m; it reopens
  Sun 20:22** names the window that runs out first for the accounts the provider's **Use** choice can send requests
  to, at the net pace of the last two hours, and when a reset opens one again; within a day it counts down, beyond it
  gives the day. The composer's usage card shows the same line under its head. An account kept out of automatic
  routing counts on its own line only: it never makes the pool read open. The line shows only when the provider runs
  out ahead; the website's dashboard shows the line your devices last published, and the `lookout usage` command and
  the MCP `lookout_usage` tool carry the same forecast. `lookout usage --follow` prints a line each time an account is
  spent or opens again, a meter drops another 5 points, or the serving account changes, with `ALERT:` lines for what
  needs you ([Follow plan usage](https://lookout.itoowasinarcadia.com/docs/cli#usage-follow)).
- The website's dashboard reads what your devices publish: the same Limits, with an account that has no plan, one its
  provider refused and one excluded from the pool drawn as here, so its pool counts match the app's.

**History** shows what was spent:

- One row of controls: the period (**24 hours**, **7 days**, **30 days**, **This month**, **Last month** or **Custom
  range**), the grouping (**Model**, **Provider**, and on this Mac **Project**, **Agent** or **Account**), **All
  devices** or **This Mac**, and **Export CSV** in the menu at its end. Signed out of your Lookout account, the page
  shows this Mac only.
- The period's tokens, its turns and the share of input the cache served, then tokens per day with one row per model,
  provider, project, agent or account. A provider is its company, with its mark: OpenAI for ChatGPT, SpaceXSI for Grok, and one
  Anthropic row for its Claude plans and its API key together. Point at a row to light its part of the chart; the list shows six rows, and **Show all** the
  rest.
- **Agent** says whose work it was: an agent's row holds its own chats, the chats it started or was handed and their
  subagents; an app that started chats over MCP (Claude Code) has its own row, and everything else is **You**. An
  agent's own project reads as the agent's name. **Account** splits a turn that several accounts served by what each
  one served. On a plan with weekly limits, **Week** says about how much of the week each row used: by agent, of the
  plan's accounts together; by account, of that account's week. Each account's total is measured from its meter and
  shared among what it served, so the split is an estimate. The `lookout usage --json` command and the MCP
  `lookout_usage` tool carry the same split per owner, and how many chats at each owner's pace the plan keeps going
  until its next reset.
- **Turns** opens every turn in the period, page by page. A turn that failed before any model answered spent no tokens,
  so it is neither counted nor listed. **Export CSV** keeps every row, with a `reached_model` column that is `false` for
  those.
- On **This Mac** every period counts all of its turns, up to a year back, however many there are: Lookout keeps daily
  totals as turns end, so History opens at once.
- On **All devices** your Lookout account adds up every turn each of your devices reported in the period, a device you
  removed included, counting tokens and turns the way **This Mac** does. Each device reports its turns every few
  minutes. The web dashboard's History reads the same totals.

## Related

- [Models and providers](https://lookout.itoowasinarcadia.com/docs/models.md): Connect the providers you have a plan with, then pick a model, its effort and its variant for each chat.
- [Account and devices](https://lookout.itoowasinarcadia.com/docs/account.md): Your Lookout account: signing up, signing in on a Mac, adding a device, the Recovery Key and the web dashboard.