Quickstart

This quickstart follows the product flow implemented in the dashboard and API today. You will create or import a TigerBeetle-backed database, wait for the profile to become ready, generate an API key, and run a safe read operation.

We will cover:

• creating a database from the dashboard or API
• what Parix queues during provisioning
• where to find the database and cluster IDs
• connecting with PARIX_API_KEY
• verifying the database from code or the query explorer

Documentation map

Use the navigation as a task map:

Prerequisites

Before you begin, make sure you have:

• a Parix account with an active organization
• billing linked for that organization, because the create flow blocks provisioning until Stripe billing is ready
• access to Settings > API keys if you want to connect from code
• an organization-wide API key when creating databases through the API

API keys can be scoped to all databases or to one specific database. Use an all-databases key for organization-wide operations such as database creation. After a database exists, a specific-database key is enough for database reads and TigerBeetle operations.

Create a database

Dashboard

Open your organization dashboard, then click New database and choose New database.

The current create form collects these fields:

• Mode: New Database provisions an empty TigerBeetle cluster. Import Database stages existing .tigerbeetle files.
• Organization and database name: the database name is the dashboard, API, and route identifier.
• Region: a provider and region pair, such as Google Cloud / Iowa (us-central1).
• Cluster configuration: Single node, HA (3 replicas), or HA (6 replicas).
• Storage type and storage size: for example, Google Persistent Disk with a selected disk size.
• Cluster size: PX sizes such as PX-5, PX-10, and larger profiles.

The summary panel shows the selected provider, region, topology, storage, node sizing, and estimated monthly price. Click Create Database when the selection is ready.

Import an existing TigerBeetle file

Choose Import Database when you already have TigerBeetle data files.

The importer expects exactly one .tigerbeetle file for each replica index in the selected topology. The UI recommends the naming pattern ${CLUSTER_ID}_${REPLICA_INDEX}.tigerbeetle, with a zero-based replica index, and still validates the embedded TigerBeetle cluster and replica metadata before upload.

Uploaded import files are staged in object storage, then the same hosted deployment flow provisions the target database.

API

Use an organization-wide API key with db:write access to create a database through the API:

curl -X POST "https://dev.parix.io/api/v1/databases" \
  -H "content-type: application/json" \
  -H "x-api-key: $PARIX_API_KEY" \
  -d '{
    "name": "wallet-demo",
    "provider": "gcp",
    "region": "us-central1",
    "selectedStorageGb": 10
  }'

If you omit optional provider, region, cluster, storage, or size fields, the API resolves the current create catalog defaults. Call GET /api/v1/catalog/create to discover provider, region, storage tier, cluster configuration, and cluster size IDs.

What happens during creation

When the dashboard or API creates a database, Parix:

• checks that the active organization can provision databases
• resolves the selected provider, region, topology, storage tier, and cluster size from the create catalog
• creates the database record and database profile
• enqueues organization audit and notification events
• starts the database provisioning workflow

The API response includes success, database, profile, job, and provisioning fields when provisioning is queued. If billing is not ready, the response can include a billing.checkoutUrl instead.

Confirm the database is ready

Open the database dashboard after creation. A ready database currently shows:

• READY status on the cluster view
• gateway connection status
• TigerBeetle version
• node count, CPU, memory, and storage usage
• database ID and cluster ID
• provider, region, and estimated monthly price

Use the database ID for API calls. The dashboard route uses the database name, for example /acme2/databases/wallet-demo.

Connect to the database

Open Connect from the database dashboard. The current connect flow has three steps.

1. Install a client library

For Node.js, the dashboard shows:

npm install @parix/tigerbeetle-node

The connect page also includes Go, Java, .NET, and Python examples.

2. Generate and use an API key

Create an API key from Settings > API keys. Secret values are shown once, so store the generated value in your environment:

export PARIX_API_KEY="px_..."

The current connection examples authenticate requests with the x-api-key header:

const response = await fetch('https://dev.parix.io/api/v1/databases/<database-id>', {
  headers: {
    'x-api-key': process.env.PARIX_API_KEY ?? '',
  },
});

3. Verify a TigerBeetle operation

The connect page verifies client setup with a lightweight account lookup:

const accounts = await client.lookupAccounts([]);
console.log('Connected successfully!', accounts.length);

For a direct HTTP check through the Parix API, run a read-only query_accounts request:

curl -X POST "https://dev.parix.io/api/v1/databases/<database-id>/tb/query_accounts" \
  -H "content-type: application/json" \
  -H "x-api-key: $PARIX_API_KEY" \
  -d '{"limit":100,"flags":0}'

The TigerBeetle API route supports these operations today:

• query_accounts
• query_transfers
• create_accounts
• create_transfers
• lookup_accounts
• lookup_transfers
• get_account_balances
• get_account_transfers

Read operations require db:read. Write operations require db:write.

Use the query explorer

The dashboard Query page provides the same operation set in a form-based explorer. It defaults to Query accounts, sends operations through the app action, and displays the result grid below the form.

Use the query explorer when you want a browser-visible smoke test before wiring an application.

Next steps

• Learn the data model in TigerBeetle.
• Follow the full onboarding path in Getting started.
• Review the dashboard surfaces in Dashboard.
• Read the connection model in Connecting overview.
• See the HTTP operation boundary in Gateway.
• Explore generated endpoint docs in API Reference.