# Your career, from the terminal.

Search jobs, update your CV and chat with the Tabbio agent without leaving the command line. It works on your Tabbio account, with the same data and approvals as the app.

Package: @tabbio-technologies/cli (command: tabbio, Node.js 20 or newer)
MCP server it uses: https://server.tabbio.com/api/mcp
Source: https://www.tabbio.com/en/cli

```sh
npx @tabbio-technologies/cli login
```

## Get started in three steps

You need Node.js 20 or newer and a Tabbio account. The free plan is enough.

1. **Install** Install the `tabbio` command, or run it once with npx.

```sh
npm i -g @tabbio-technologies/cli
npx @tabbio-technologies/cli
```

2. **Sign in** `tabbio login` opens your browser to approve this computer. On a server, add `--email` to get a code by email. In CI, set `TABBIO_TOKEN` instead.

```sh
tabbio login
tabbio login --email you@example.com
export TABBIO_TOKEN=tabbio_mcp_...
```

3. **Run** List your CVs, search the job catalog as JSON, or open a chat.

```sh
tabbio cv list
tabbio catalog job-search --query "designer" --json
tabbio chat
```

Something off? `tabbio doctor` checks your setup and says what to fix.

## What you can do from the terminal

The CLI reaches the same 162 tools as the Tabbio MCP server, plus chat, approvals and output your scripts can read.

### Every tool is a command

Each tool becomes a command such as `tabbio cv list`, with flags built from the tool's own schema. Browse them in an interactive list, or print one tool's flags with `tabbio tools describe`.

`cv list`, `catalog job-search`, `profile update`, `cv tailor`

### Chat with the Tabbio agent

`tabbio chat` streams the answer as it is written, shows each tool the agent calls and keeps your threads. Slash commands switch mode, model and thread, and, where your account has them, turn on web research, images, or an answer as a document, slides or a page.

`tabbio chat`, `/threads`, `/research on`, `--result document`

### Approve in the terminal

Actions that send, share, publish or delete stop for your approval. The CLI shows the tool and its arguments, and you approve, reject or leave it pending. `--yes` approves only what that one command created.

`approvals`, `approvals approve`, `approvals wait`, `--yes`

### Scripts and CI

`--json` prints a stable envelope with a schema version. Piped output becomes tab-separated rows, exit codes say what happened, and `TABBIO_TOKEN` signs a job in without writing anything to disk.

`--json`, `--fields`, `TABBIO_TOKEN`, `help exit-codes`

### A bridge for MCP clients

Some MCP clients only start local servers. `tabbio mcp serve` speaks MCP over stdin and stdout and forwards every call to Tabbio with your CLI sign-in. Clients that support remote servers can take `tabbio mcp url` instead.

`mcp serve`, `mcp url`

```json
{
  "mcpServers": {
    "tabbio": {
      "command": "npx",
      "args": [
        "-y",
        "@tabbio-technologies/cli",
        "mcp",
        "serve"
      ]
    }
  }
}
```

### One sign-in, three ways

Approve the computer in your browser, use a code sent by email over SSH, or bring a personal token for CI. Credentials sit in a file only you can read (mode 0600), tokens are never printed, `tabbio logout` ends the session, and approvals still apply.

`login`, `login --email`, `login --with-token`, `logout`

## Command reference

```
tabbio                                   TTY: interactive home. Non-TTY: help.
tabbio login [--browser | --email <addr> | --token <tabbio_mcp_…> | --with-token] [--non-interactive] [--profile p] [--api-url u] [--app-url u]
tabbio logout [--all]
tabbio status                            profile, API/MCP urls, user, plan, sign-in kind (app session | personal token …xxxx), pending approvals, catalog age
tabbio whoami [--json]
tabbio doctor                            node version, config perms, /api/health, MCP tools/list, JWT validity, clock skew
tabbio config list|get <k>|set <k> <v>|path ; tabbio config profile list|use <name>|add <name> --api-url … --app-url …
tabbio tools [query] [--group g] [--writes|--reads] [--json] [--refresh]     TTY: browser; else list
tabbio tools describe <tool.id> [--json]                                    schema as flags + example
tabbio run <tool.id> [--<flag> …] [--input '<json>' | --input-file f | -] [--wait] [--yes] [--json|--table|--plain] [--fields a,b]
tabbio <group> <action> [flags]          generated for every catalog tool (same options as run)
tabbio workflows                         says that workflows are not exposed over MCP (they run inside chat)
tabbio approvals [list] [--json] ; approvals show <id> ; approvals approve <id> [--reason r] [--wait] ; approvals reject <id> [--reason r] ; approvals wait <id> [--timeout 10m]
tabbio artifacts [list] [--kind k] [--status s] ; artifacts get|open|versions|delete|wait <id> ; artifacts download <id> [--format f] [--out p] [--force] [--wait] ; artifacts restore <id> <versionId>
tabbio ask "<question>" [--mode m] [--via-mcp] [--json]   one question through the chat stream (app session)
tabbio chat [message] [--mode seeker|employer] [--company <id>] [--thread <id>] [--model <id>] [--research auto|on|off] [--image auto|on|off] [--result auto|summary|document|slides|page|image] [--save] [--json]
tabbio mcp serve [--profile p]          stdio ↔ remote MCP bridge for stdio-only clients
tabbio mcp url                          prints the MCP URL for `claude mcp add`
tabbio completion bash|zsh|fish
tabbio help exit-codes
tabbio --version | --help | --debug | --color | --no-color | --json
```

## Made for automation

Every command has a plain-text path for pipes and CI. Without a terminal, or with CI set, the CLI never draws its interactive screens and never prompts.

```json
{
  "data": {
    "cvs": [
      {
        "id": "cv_seeker_1_primary",
        "title": "Amina Noor - Product Design",
        "isPublic": true,
        "updatedAt": "2026-08-01T09:12:44.000Z"
      }
    ],
    "defaultCvId": "cv_seeker_1_primary",
    "total": 19
  },
  "meta": {
    "schemaVersion": 1,
    "tool": "cv.list",
    "durationMs": 31
  }
}
```

Output of `tabbio cv list --json`, trimmed to one CV. Within a schema version, fields are only added, never renamed or removed.

```yaml
- run: npx -y @tabbio-technologies/cli run cv.list --json > cvs.json
  env:
    TABBIO_TOKEN: ${{ secrets.TABBIO_TOKEN }}
```

### Exit codes

- `0` Success
- `1` Unexpected error
- `2` Usage error, such as a missing flag
- `3` Not signed in
- `4` Not allowed by token scope, plan or credits
- `5` Not found
- `6` Waiting for approval
- `7` Network error
- `8` Server error
- `130` Interrupted with Ctrl+C

### Works where you work

- **macOS** Node.js 20 or newer, in any terminal.
- **Linux** Desktops, servers and containers. Sign in over SSH with a code sent by email.
- **Windows** Node.js 20 or newer. The credentials file relies on your Windows user profile's permissions.
- **CI** Set TABBIO_TOKEN from your secrets. No prompts and no interactive screens.

## Free to start

Free accounts get a daily credit pool, the same one the app draws from. Chat replies and AI tools such as CV tailoring spend it, and most tools make no AI call and cost nothing. https://www.tabbio.com/en/pricing

## Tabbio CLI questions

### What is the Tabbio CLI?

A command-line client for your Tabbio account. It turns every tool on the Tabbio MCP server into a command, streams chat with the Tabbio agent, lets you approve actions in the terminal and prints JSON for scripts. It runs anywhere Node.js 20 or newer does.

### Do I need the Tabbio app?

You need a Tabbio account, and the free plan is enough. You approve the first sign-in in your browser, then the CLI works on its own. It uses the same account, data and limits as the app, so a CV you change in the terminal is the same CV in the app.

### Is it safe, and what does it store?

It keeps one sign-in per profile in a credentials file only your user can read (mode 0600, in a folder set to 0700). It never prints tokens, and debug output and errors redact them. `tabbio logout` ends the session on the server, and if you lose the computer, changing your password signs out every device at once. It sends no telemetry, and apart from a daily check for a new version on npm, which you can turn off, it only talks to Tabbio.

### Does it work with a personal MCP token?

Yes. Run `tabbio login --with-token` and paste a token from Settings, then MCP access, or set `TABBIO_TOKEN`. A token reaches the tools within its scope, while chat and approving actions need a browser or email sign-in. The CLI never creates a token itself, so it cannot replace the one another client uses.

### What needs my approval?

Anything hard to undo or that reaches other people, such as deleting, submitting or withdrawing an application, sending a message or email, sharing a CV, publishing and starting automations. The CLI shows the tool and its arguments and waits. `--yes` approves only the actions that one command created, and only with a full sign-in. Nothing approves a whole session for you.

### Can I use it in CI?

Yes. Store a personal token as a CI secret, expose it as `TABBIO_TOKEN` and add `--json`. With CI set, the CLI never prompts or draws its interactive screens, and exit codes tell your script what happened. Code 6 means an action is waiting for approval, and 4 means a scope, plan or credit limit.

### How is it different from the MCP server?

The MCP server connects AI clients such as Claude, ChatGPT and Cursor to your account. The CLI is for you and your scripts at a terminal, with the same tools plus streaming chat and approvals. It can also bridge the server to clients that only start local servers, with `tabbio mcp serve`. To connect an AI client, follow the MCP setup guide.

MCP setup guide: https://www.tabbio.com/en/mcp