> ## Documentation Index
> Fetch the complete documentation index at: https://docs.anonalabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Temporary profiles

> Let an agent store memories before anyone has an account, then claim the result later.

## What it is

Normally you sign up, then connect an agent. A temporary profile inverts that.
`anona start` gives an agent a working memory **before any account exists**. A
person claims the result afterwards with `anona login`, and the memories the
agent stored while it waited are theirs.

A temporary profile is a memory workspace with no email address, no password
and nobody owning it. The only thing that identifies it is an opaque token
starting `anona_tmp_`, which the CLI keeps in `~/.anona/credentials.json` (mode
600\). The server keeps only a hash of it. The token is never printed, so that
file is its only copy.

That token works wherever an API key does, and on the remote `/mcp` endpoint,
so an agent can use it without a browser or a human in the loop.

## The limits

| | Unclaimed profile | Claimed account |
| - | - | - |
| Credits | **1,000** | 5,000 |
| Lifetime | **72 hours**, then deleted | No expiry |
| Owner | Nobody | You |

<Warning>
  **Nothing warns you before the 72 hours are up.** There is no email address to
  send a warning to. When the deadline passes the profile's memories are deleted
  and the token stops working. `anona status` is the only place the deadline
  shows, so check it, or claim the profile.
</Warning>

## Start to finish

<Steps>
  <Step title="Install the CLI">
    Either package works. They share one credential file, so you can start with
    one and claim with the other.

    ```bash theme={null}
    pip install anona                  # needs 0.19.0 or later
    npm install -g @anona-labs/memory  # needs 0.16.0 or later
    ```

    With nothing installed: `uvx --from anona anona start`, or
    `npx @anona-labs/memory start`.
  </Step>

  <Step title="Start a profile">
    ```bash theme={null}
    anona start
    ```

    ```
    Temporary profile created. It expires 2026-10-06 15:22 UTC (in 71 hours), after which its memories are deleted.
    Nothing warns you before then: run `anona status` to check, and
    `anona login` to claim it and keep what it holds.
    Its space is created by the first memory written to it.
    ```

    Note the expiry. If a profile is already stored, `anona start` prints its
    deadline and creates nothing.
  </Step>

  <Step title="Connect your client">
    ```bash theme={null}
    claude mcp add anona -- anona mcp
    ```

    Restart the client so it loads the tools. Then `record` something. The
    profile starts with a space called `default`, but the space itself is
    created by the first write, so a `retrieve` before any `record` reports that
    the space does not exist.
  </Step>

  <Step title="Check the deadline">
    ```bash theme={null}
    anona status
    ```

    ```
    Temporary profile for https://api.anonalabs.com: expires 2026-10-06 15:22 UTC (in 70 hours), after which its memories are deleted.
    Run `anona login` to claim it before then.
    ```

    `status` reads only the local file. It cannot tell you the server still
    holds the profile.
  </Step>

  <Step title="Claim it">
    ```bash theme={null}
    anona login
    ```

    A browser opens on the approval screen, where you sign up (or sign in with
    Google). Read the client name, then choose **Allow**. Over SSH or in a
    container, `anona login` prints the URL instead; open it on the machine
    running the command, or add `--no-browser` to skip the attempt to open one.
  </Step>

  <Step title="Confirm">
    ```bash theme={null}
    anona status
    ```

    The temporary-profile lines are gone, replaced by the stored sign-in
    credential. The dashboard now shows the account with its real balance, and
    the confirmation email names the space.
  </Step>
</Steps>

## What claiming does

You do not move anything. `anona login` attaches your new account to the
workspace that already holds the agent's memories, and renames that workspace to
the organization name you chose at signup. Afterwards it is an ordinary account,
indistinguishable from one that signed up first.

* **The ceiling rises from 1,000 to 5,000 credits.**
* **Credits already spent carry over.** A profile that used 800 credits has
  4,200 left, not 5,000. The allowance cannot be collected twice by claiming.
* **The memories are the same ones.** Nothing is copied, so nothing is lost or
  duplicated.
* **The temporary token is destroyed.** Whatever the agent was holding stops
  working, and you use the account's own sign-in or an API key from here on.
* **A confirmation email** names the space and your real balance.

### Claiming needs a new account

Claiming works because you have no workspace of your own yet. If you sign in
with an address that already has an Anona account, the claim is refused with
`claim_needs_new_account` (HTTP 409), and the profile's memories **cannot** be
moved into the existing account. Sign up with an address that has never been
used for Anona, or let the profile expire.

An account that has already done things (created an API key, recorded usage,
invited a colleague, or subscribed) counts as having a workspace of its own,
even if it was created recently.

## Check the credit ceiling

The temporary token can read its own balance. The figures in the reply below are illustrative:

```bash theme={null}
curl https://api.anonalabs.com/v1/usage/me \
  -H "Authorization: Bearer anona_tmp_YOUR_TOKEN"
```

```json theme={null}
{ "credits_remaining": 989, "credits_limit": 1000, "credits_used": 11, "rate_limit_per_min": 20 }
```

The token is in `~/.anona/credentials.json` under `temp_token`. Treat it like
an API key: anyone holding it can read and write the profile. Past the ceiling, metered calls are
refused in the standard error envelope with a lowercase `code`; see
[error codes](/api-reference/errors).

Read it before and after claiming to see the effect. In the first production
run, 11 credits used before the claim read `5000 limit / 11 used / 4989
remaining` after it. The temporary token stops working once claimed, so after
the claim make the same call with an API key from the dashboard.

## Abandoning one

`anona logout` refuses to delete a live unclaimed profile, because the token
exists nowhere else and deleting the file strands the profile and everything in
it until the server removes it:

```bash theme={null}
anona logout          # refused while a live unclaimed profile is stored
anona logout --force  # discards it. This cannot be undone
```

Signing in to a different server with `anona login --base-url ...` also
replaces the stored profile. It prints a note first.

## Failure modes

| You see | Meaning |
| - | - |
| `anona start: Too many temporary profiles from this address today.` | Profile creation is limited to 5 a day per address. Try again tomorrow. |
| `anona start: The server refused to create a profile (404)` | The server has the feature switched off. Use `anona login` instead. |
| `anona start: you are already signed in` | A signed-in credential is stored. Run `anona logout` first if you want a profile. |
| `temp_profile_expired` (401) | The 72 hours have passed. The memories are deleted. |
| `temp_profile_unclaimable` (409) | The profile is already claimed, expired or unknown. Run `anona start` for a new one. |
| `claim_needs_new_account` (409) | The signing-in address already has an account. See above. |

## Related

* [The anona CLI](/agents/cli) covers `login`, `logout`, `status` and `mcp`.
* [Self-onboarding prompt](/agents/onboarding-prompt) is a prompt that does all
  of this for you, and reports back when it is done.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.