Install and use the Anythink CLI

The anythink command-line tool manages a project from your terminal: entities, fields, records, search, users, roles, API keys, workflows, integrations, secrets, files, menus and payments. It talks to the same REST API as the Anythink dashboard, so a command succeeds only if you could make the same request yourself.

This page covers installing the CLI, signing in, managing profiles and the command groups. For a guided build, follow Build your first app.

Install#

Pick one method. Each puts an anythink command on your PATH.

Homebrew taps anythink-cloud/tap automatically when you use the full name. To tap it first, run brew tap anythink-cloud/tap, then brew install anythink.

Download a binary#

Each GitHub release publishes a standalone binary per platform:

curl -Lo anythink https://github.com/anythink-cloud/anythink-cli/releases/latest/download/anythink-osx-arm64
chmod +x anythink
sudo mv anythink /usr/local/bin/

Check the download against checksums.txt from the same release with sha256sum -c checksums.txt --ignore-missing.

Check it works#

anythink --version
anythink --help

--version prints the version number. --help lists every command group, and anythink <group> --help lists a group's subcommands and options.

Sign up, sign in and pick a project#

The CLI uses two kinds of credential. A platform session, from signup or login, lets you manage billing accounts and projects. A project profile, created by projects use or an API-key login, lets you work on one project's data.

anythink signup
anythink login
anythink accounts use
anythink projects create "My App" --region lon1
anythink projects use my-app

Your credentials live in ~/.anythink/config.json. Treat that file like a password.

Sign in with an API key#

If you already have a project's org id and an API key, skip the billing steps:

anythink login --org-id <org-id> --api-key <api-key>

This saves a profile named after the org id and makes it active. An API key needs no browser or password prompt, so it's the sign-in to use for scripts and CI. See API keys for creating one.

Profiles#

A profile holds the credentials for one project. List them with config show, which also shows the platform sessions and marks the active profile.

The active profile is shared#

config use and projects use write the active profile to ~/.anythink/config.json, so every terminal and every tool on the machine uses it. If you switch to a staging project in one terminal, a command already queued in another terminal runs against staging too. An editor integration or an AI assistant using the anythink-mcp server shares the same setting.

To avoid running a command against the wrong project, name the profile on each command:

anythink --profile my-app-staging data list orders --limit 5
anythink --profile my-app-production entities list

--profile <name> (or -p <name>) applies to that command only and never changes the active profile. It works anywhere in the command line and on every command that talks to a project. If the profile doesn't exist, the command stops with Profile '<name>' not found. The commands that use your platform session (signup, login, accounts, projects and plans) don't take a project profile.

Keep one profile per environment, give each a clear name, and use --profile in scripts. Run config show before any command that changes or deletes data if you rely on the active profile.

Global options and output#

Commands that ask for confirmation, such as entities delete, data delete, files delete and projects delete, stop and wait without --yes. Add it for scripts. Delete commands remove data permanently.

The CLI colours tables and messages for a terminal. When you pipe or redirect the output, it writes plain text without colour codes, so anythink data list orders --json | jq is safe to parse.

For paging through everything:

anythink data list orders --json --all > orders.json

Command reference#

Each table lists the commands in one group. Run anythink <group> <command> --help for every option.

entities#

An entity is a database table in your project.

fields#

To change an existing field, use the Anythink dashboard.

data#

--filter takes a JSON object such as {"status":"draft","price":{"gte":10}} or field=value pairs joined with &, such as status=draft&price=GTE:10.

search#

See Search records across your entities for how indexing works.

users#

To invite users, use the Anythink dashboard.

roles#

Manage a role's permissions in the Anythink dashboard.

api-keys#

The key is shown once and can't be retrieved later. --save-as stores it straight into a profile, so it never prints. See API keys.

workflows#

Pass step parameters as a single JSON string, escaping the quotes inside it as shown. To switch a workflow on when you create it, use workflows create --enabled. See How workflows work.

integrations#

oauth#

To set up Google sign-in, use the Anythink dashboard. See Social sign-in with Apple, Google, GitHub and LinkedIn.

secrets#

See Store API keys and tokens as secrets.

files#

menus#

pay#

plans, migrate, api and docs#

migrate writes to the destination project. Run it with --dry-run first and check which profile is named in --to.

Call any endpoint with fetch#

anythink fetch sends an authenticated request to your project's REST API. Give it a path after the project, because the CLI adds /org/<project-id> for you.

anythink fetch /entities
anythink fetch /integrations/definitions
anythink fetch /integrations/connections --method POST --body '{"name":"test"}'

The CLI prints the request line first, then the response as formatted JSON. It uses the active profile, or the one you name with --profile, and your permissions apply. See REST API reference for the endpoints.

Use the CLI in CI#

Sign in with an API key so the job needs no interactive step and no browser. Create a key with only the permissions the job needs, save the org id and key as secrets in your CI system, then sign in at the start of the job:

anythink login --org-id "$ANYTHINK_ORG_ID" --api-key "$ANYTHINK_API_KEY"
anythink data list orders --json --all > orders.json

On a fresh machine this creates the only profile and makes it active. If the runner also holds profiles for other projects, add --profile <name> to each command.

A GitHub Actions job that installs the Linux binary and exports a nightly snapshot:

name: Export orders
on:
  schedule:
    - cron: "0 6 * * *"
jobs:
  export:
    runs-on: ubuntu-latest
    steps:
      - name: Install the Anythink CLI
        run: |
          curl -Lo anythink https://github.com/anythink-cloud/anythink-cli/releases/latest/download/anythink-linux-x64
          chmod +x anythink
          sudo mv anythink /usr/local/bin/
      - name: Sign in with an API key
        env:
          ANYTHINK_ORG_ID: ${{ secrets.ANYTHINK_ORG_ID }}
          ANYTHINK_API_KEY: ${{ secrets.ANYTHINK_API_KEY }}
        run: anythink login --org-id "$ANYTHINK_ORG_ID" --api-key "$ANYTHINK_API_KEY"
      - name: Export records
        run: anythink data list orders --json --all > orders.json
      - uses: actions/upload-artifact@v4
        with:
          name: orders
          path: orders.json

Add --yes to any command that deletes or overwrites data. search audit exits with code 1 when public search returns fields that aren't marked public, so you can use it as a CI check.

Next steps#