From b0a8f8d9f16321858f394bfb91204c2b6e309d8c Mon Sep 17 00:00:00 2001
From: eileencodes <eileencodes@gmail.com>
Date: Thu, 10 Sep 2026 10:03:00 -0400
Subject: [PATCH] Add Neki support to the CLI

Neki databases can be created, connected, restored, and operated from
pscale. Existing Postgres commands that apply (sql, shell, role,
maintenance) accept Neki as well.

New and extended commands:

```
pscale database create --engine neki
pscale logs <database> <branch>
pscale size cluster list --engine neki
pscale branch data-topology get|ls|update
pscale branch shard list|show|create|assign|update|delete
pscale branch config-profile list|show|create|update|delete
pscale branch config-profile default|set-default|parameters|maintenance
pscale branch config-profile extensions|extensions enable|extensions disable
pscale branch config-profile changes list|show|cancel
pscale branch router list|show|create|update|delete|sizes
pscale branch router changes list|show|cancel
pscale branch sidecar list|show|update|parameters
pscale branch sidecar changes list|show|cancel
pscale branch admin show|update|parameters|sizes
pscale branch admin changes list|show|cancel
pscale branch maintenance run
pscale backup restore
pscale backup restore show
```

Neki restore accepts --config-profile and --router; --cluster-size is
optional so the source default profile size is kept. Shell accepts
--router for Neki routing.
---
 AGENTS.md                                     | 256 +++++++-
 internal/cmd/admin/admin.go                   | 234 +++++++
 internal/cmd/admin/admin_test.go              | 364 +++++++++++
 internal/cmd/admin/changes.go                 | 154 +++++
 internal/cmd/admin/errors.go                  |  18 +
 internal/cmd/admin/parameters.go              |  49 ++
 internal/cmd/admin/show.go                    |  64 ++
 internal/cmd/admin/sizes.go                   |  82 +++
 internal/cmd/admin/update.go                  |  97 +++
 internal/cmd/backup/backup.go                 |   2 +-
 internal/cmd/backup/restore.go                |  34 +-
 internal/cmd/backup/restore_show.go           | 177 ++++++
 internal/cmd/backup/restore_show_test.go      | 183 ++++++
 internal/cmd/backup/restore_test.go           | 143 +++++
 internal/cmd/branch/branch.go                 |  85 ++-
 internal/cmd/branch/branch_test.go            |  45 ++
 internal/cmd/branch/connections.go            |  11 +-
 .../cmd/branch/connections/engine_flags.go    |   5 +
 .../branch/connections/engine_flags_test.go   |  16 +
 internal/cmd/branch/connections/top.go        |   2 +-
 internal/cmd/branch/connections/top_test.go   |   6 +
 internal/cmd/branch/connections_commands.go   |   3 +
 internal/cmd/branch/connections_test.go       |  41 ++
 internal/cmd/branch/create.go                 |  38 +-
 internal/cmd/branch/create_test.go            | 265 ++++++++
 internal/cmd/branch/data_topology.go          | 208 ++++++
 internal/cmd/branch/data_topology_output.go   |  36 ++
 internal/cmd/branch/data_topology_shards.go   |  79 +++
 internal/cmd/branch/data_topology_test.go     | 426 +++++++++++++
 internal/cmd/branch/data_topology_tree.go     | 593 ++++++++++++++++++
 internal/cmd/branch/diff.go                   |   2 +-
 internal/cmd/branch/lint.go                   |   2 +-
 internal/cmd/branch/maintenance.go            |  21 +-
 internal/cmd/branch/maintenance_test.go       | 157 ++---
 internal/cmd/branch/query_patterns.go         |   4 +-
 internal/cmd/branch/refresh_schema.go         |   2 +-
 internal/cmd/branch/routing_rules.go          |   6 +-
 internal/cmd/branch/safe_migrations.go        |   6 +-
 internal/cmd/configprofile/changes.go         | 158 +++++
 internal/cmd/configprofile/config_profile.go  | 366 +++++++++++
 .../cmd/configprofile/config_profile_test.go  | 465 ++++++++++++++
 internal/cmd/configprofile/create.go          |  64 ++
 internal/cmd/configprofile/default.go         |  38 ++
 internal/cmd/configprofile/delete.go          |  62 ++
 internal/cmd/configprofile/errors.go          |  19 +
 internal/cmd/configprofile/extensions.go      |  95 +++
 internal/cmd/configprofile/list.go            |  44 ++
 internal/cmd/configprofile/maintenance.go     |  80 +++
 internal/cmd/configprofile/parameters.go      |  74 +++
 internal/cmd/configprofile/set_default.go     |  44 ++
 internal/cmd/configprofile/show.go            |  40 ++
 internal/cmd/configprofile/update.go          | 100 +++
 internal/cmd/database/create.go               |  47 +-
 internal/cmd/database/create_test.go          |  72 ++-
 internal/cmd/keyspace/keyspace.go             |   2 -
 internal/cmd/keyspace/settings.go             |   8 -
 internal/cmd/keyspace/update_settings.go      |  40 +-
 internal/cmd/keyspace/update_settings_test.go | 241 -------
 internal/cmd/logs/logs.go                     | 327 ++++++++++
 internal/cmd/logs/logs_test.go                | 287 +++++++++
 internal/cmd/role/create.go                   |   4 +-
 internal/cmd/role/get.go                      |  13 +-
 internal/cmd/role/list.go                     |  47 +-
 internal/cmd/role/output_test.go              | 302 +++++++++
 internal/cmd/role/renew.go                    |   2 +-
 internal/cmd/role/reset.go                    |   2 +-
 internal/cmd/role/reset_default.go            |  45 +-
 internal/cmd/role/role.go                     |   4 +-
 internal/cmd/role/update.go                   |   2 +-
 internal/cmd/root.go                          |  21 +-
 internal/cmd/root_test.go                     |  11 +
 internal/cmd/router/changes.go                | 158 +++++
 internal/cmd/router/create.go                 |  60 ++
 internal/cmd/router/delete.go                 |  63 ++
 internal/cmd/router/errors.go                 |  23 +
 internal/cmd/router/list.go                   |  48 ++
 internal/cmd/router/router.go                 | 319 ++++++++++
 internal/cmd/router/router_test.go            | 471 ++++++++++++++
 internal/cmd/router/show.go                   |  65 ++
 internal/cmd/router/sizes.go                  |  90 +++
 internal/cmd/router/update.go                 | 124 ++++
 internal/cmd/shard/assign.go                  |  51 ++
 internal/cmd/shard/create.go                  |  60 ++
 internal/cmd/shard/delete.go                  |  63 ++
 internal/cmd/shard/errors.go                  |  28 +
 internal/cmd/shard/list.go                    |  68 ++
 internal/cmd/shard/shard.go                   | 130 ++++
 internal/cmd/shard/shard_test.go              | 287 +++++++++
 internal/cmd/shard/show.go                    |  44 ++
 internal/cmd/shard/update.go                  |  61 ++
 internal/cmd/shell/shell.go                   |  63 +-
 internal/cmd/shell/shell_test.go              |  38 ++
 internal/cmd/sidecar/changes.go               | 158 +++++
 internal/cmd/sidecar/errors.go                |  23 +
 internal/cmd/sidecar/list.go                  |  48 ++
 internal/cmd/sidecar/parameters.go            |  50 ++
 internal/cmd/sidecar/show.go                  |  66 ++
 internal/cmd/sidecar/sidecar.go               | 217 +++++++
 internal/cmd/sidecar/sidecar_test.go          | 323 ++++++++++
 internal/cmd/sidecar/update.go                |  84 +++
 internal/cmd/size/cluster.go                  |  90 +--
 internal/cmd/size/cluster_test.go             |  59 +-
 internal/cmd/sql/sql.go                       |   4 +-
 internal/cmdutil/args_test.go                 |  25 +
 internal/cmdutil/cmdutil.go                   | 183 ++++++
 internal/cmdutil/json_error.go                |   5 +-
 internal/cmdutil/json_error_test.go           |  10 +
 internal/cmdutil/neki_restore_test.go         |  82 +++
 internal/cmdutil/postgres.go                  |  23 +
 internal/mock/branch.go                       |  16 +
 internal/mock/neki_admins.go                  |  65 ++
 internal/mock/neki_routers.go                 |  89 +++
 .../mock/neki_shard_configuration_profiles.go |  92 +++
 internal/mock/neki_shards.go                  |  57 ++
 internal/mock/neki_sidecars.go                |  65 ++
 internal/planetscale/branches.go              |   2 +
 internal/planetscale/client.go                | 106 ++--
 internal/planetscale/data_topology.go         |  62 ++
 internal/planetscale/data_topology_test.go    |  85 +++
 internal/planetscale/databases.go             |   1 +
 internal/planetscale/keyspaces.go             |  17 -
 internal/planetscale/keyspaces_test.go        |  43 --
 internal/planetscale/logs.go                  | 108 ++++
 internal/planetscale/logs_test.go             | 107 ++++
 internal/planetscale/neki_admins.go           | 204 ++++++
 internal/planetscale/neki_admins_test.go      | 118 ++++
 internal/planetscale/neki_routers.go          | 300 +++++++++
 internal/planetscale/neki_routers_test.go     | 269 ++++++++
 .../neki_shard_configuration_profiles.go      | 411 ++++++++++++
 .../neki_shard_configuration_profiles_test.go | 241 +++++++
 internal/planetscale/neki_shards.go           | 214 +++++++
 internal/planetscale/neki_shards_test.go      | 138 ++++
 internal/planetscale/neki_sidecars.go         | 202 ++++++
 internal/planetscale/neki_sidecars_test.go    | 111 ++++
 internal/planetscale/postgres_branches.go     |  20 +
 .../planetscale/postgres_branches_test.go     |  66 ++
 internal/planetscale/postgres_roles.go        |   4 +-
 internal/planetscale/postgres_roles_test.go   |  60 ++
 internal/roleutil/roleutil.go                 |  55 ++
 internal/roleutil/roleutil_test.go            | 106 ++++
 internal/sqlquery/session.go                  |   4 +-
 internal/sqlquery/sqlquery.go                 |  12 +-
 internal/sqlquery/sqlquery_test.go            |  63 ++
 143 files changed, 13654 insertions(+), 665 deletions(-)
 create mode 100644 internal/cmd/admin/admin.go
 create mode 100644 internal/cmd/admin/admin_test.go
 create mode 100644 internal/cmd/admin/changes.go
 create mode 100644 internal/cmd/admin/errors.go
 create mode 100644 internal/cmd/admin/parameters.go
 create mode 100644 internal/cmd/admin/show.go
 create mode 100644 internal/cmd/admin/sizes.go
 create mode 100644 internal/cmd/admin/update.go
 create mode 100644 internal/cmd/backup/restore_show.go
 create mode 100644 internal/cmd/backup/restore_show_test.go
 create mode 100644 internal/cmd/branch/branch_test.go
 create mode 100644 internal/cmd/branch/connections/engine_flags_test.go
 create mode 100644 internal/cmd/branch/data_topology.go
 create mode 100644 internal/cmd/branch/data_topology_output.go
 create mode 100644 internal/cmd/branch/data_topology_shards.go
 create mode 100644 internal/cmd/branch/data_topology_test.go
 create mode 100644 internal/cmd/branch/data_topology_tree.go
 create mode 100644 internal/cmd/configprofile/changes.go
 create mode 100644 internal/cmd/configprofile/config_profile.go
 create mode 100644 internal/cmd/configprofile/config_profile_test.go
 create mode 100644 internal/cmd/configprofile/create.go
 create mode 100644 internal/cmd/configprofile/default.go
 create mode 100644 internal/cmd/configprofile/delete.go
 create mode 100644 internal/cmd/configprofile/errors.go
 create mode 100644 internal/cmd/configprofile/extensions.go
 create mode 100644 internal/cmd/configprofile/list.go
 create mode 100644 internal/cmd/configprofile/maintenance.go
 create mode 100644 internal/cmd/configprofile/parameters.go
 create mode 100644 internal/cmd/configprofile/set_default.go
 create mode 100644 internal/cmd/configprofile/show.go
 create mode 100644 internal/cmd/configprofile/update.go
 create mode 100644 internal/cmd/logs/logs.go
 create mode 100644 internal/cmd/logs/logs_test.go
 create mode 100644 internal/cmd/role/output_test.go
 create mode 100644 internal/cmd/router/changes.go
 create mode 100644 internal/cmd/router/create.go
 create mode 100644 internal/cmd/router/delete.go
 create mode 100644 internal/cmd/router/errors.go
 create mode 100644 internal/cmd/router/list.go
 create mode 100644 internal/cmd/router/router.go
 create mode 100644 internal/cmd/router/router_test.go
 create mode 100644 internal/cmd/router/show.go
 create mode 100644 internal/cmd/router/sizes.go
 create mode 100644 internal/cmd/router/update.go
 create mode 100644 internal/cmd/shard/assign.go
 create mode 100644 internal/cmd/shard/create.go
 create mode 100644 internal/cmd/shard/delete.go
 create mode 100644 internal/cmd/shard/errors.go
 create mode 100644 internal/cmd/shard/list.go
 create mode 100644 internal/cmd/shard/shard.go
 create mode 100644 internal/cmd/shard/shard_test.go
 create mode 100644 internal/cmd/shard/show.go
 create mode 100644 internal/cmd/shard/update.go
 create mode 100644 internal/cmd/sidecar/changes.go
 create mode 100644 internal/cmd/sidecar/errors.go
 create mode 100644 internal/cmd/sidecar/list.go
 create mode 100644 internal/cmd/sidecar/parameters.go
 create mode 100644 internal/cmd/sidecar/show.go
 create mode 100644 internal/cmd/sidecar/sidecar.go
 create mode 100644 internal/cmd/sidecar/sidecar_test.go
 create mode 100644 internal/cmd/sidecar/update.go
 create mode 100644 internal/cmdutil/args_test.go
 create mode 100644 internal/cmdutil/neki_restore_test.go
 create mode 100644 internal/mock/neki_admins.go
 create mode 100644 internal/mock/neki_routers.go
 create mode 100644 internal/mock/neki_shard_configuration_profiles.go
 create mode 100644 internal/mock/neki_shards.go
 create mode 100644 internal/mock/neki_sidecars.go
 create mode 100644 internal/planetscale/data_topology.go
 create mode 100644 internal/planetscale/data_topology_test.go
 create mode 100644 internal/planetscale/logs.go
 create mode 100644 internal/planetscale/logs_test.go
 create mode 100644 internal/planetscale/neki_admins.go
 create mode 100644 internal/planetscale/neki_admins_test.go
 create mode 100644 internal/planetscale/neki_routers.go
 create mode 100644 internal/planetscale/neki_routers_test.go
 create mode 100644 internal/planetscale/neki_shard_configuration_profiles.go
 create mode 100644 internal/planetscale/neki_shard_configuration_profiles_test.go
 create mode 100644 internal/planetscale/neki_shards.go
 create mode 100644 internal/planetscale/neki_shards_test.go
 create mode 100644 internal/planetscale/neki_sidecars.go
 create mode 100644 internal/planetscale/neki_sidecars_test.go
 create mode 100644 internal/roleutil/roleutil_test.go

diff --git a/AGENTS.md b/AGENTS.md
index 214f5419b..cf5e825b3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -240,7 +240,7 @@ pscale sql <database> <branch> --org <org> --format json --query "SELECT 1"
 # Read from replica
 pscale sql <database> <branch> --org <org> --format json --replica --query "SELECT 1"
 
-# PostgreSQL — optional --dbname (default postgres)
+# Postgres or Neki — optional --dbname (default postgres)
 pscale sql <database> <branch> --org <org> --format json --query "SELECT 1"
 
 # MySQL multi-keyspace — optional --keyspace (default @primary)
@@ -251,11 +251,11 @@ pscale sql <database> <branch> --org <org> --format json --keyspace <keyspace> -
 |------|---------|
 | `--role` | `reader` (default), `writer`, `readwriter`, `admin` — same names as `pscale shell` |
 | `--replica` | Route reads to replicas |
-| `--dbname` | PostgreSQL database name (default `postgres`) |
+| `--dbname` | Postgres or Neki database name (default `postgres`) |
 | `--keyspace` | MySQL keyspace (default `@primary`); may include a shard and tablet type: `mykeyspace/-80`, `mykeyspace/-80@replica` |
 | `--force` | Allow destructive SQL after explicit user approval |
 
-**`--role` by engine** (same as `pscale shell`):
+**`--role` by engine** (same as `pscale shell`; Neki uses the Postgres behavior):
 
 | `--role` | MySQL (Vitess) | PostgreSQL |
 |----------|----------------|------------|
@@ -287,6 +287,41 @@ Error: one JSON object on stdout with `status: "error"`, `error`, `issues`, and
 
 Destructive SQL without `--force`: `status: "action_required"`, `query_kind: "destructive"`, `issues`, and `next_steps` (includes `--force` retry command).
 
+## Branch logs
+
+`pscale logs` queries recent logs for a PostgreSQL or Neki branch. It obtains a signed logs URL from the API and prints parsed entries; API credentials are not sent to the signed logs host.
+
+```bash
+# Last hour from the primary server (default)
+pscale logs <database> <branch> --org <org> --format json
+
+# Search errors across the last six hours
+pscale logs <database> <branch> --org <org> --format json --period 6h --level ERROR --query "connection refused"
+
+# Query an exact ISO 8601 time range
+pscale logs <database> <branch> --org <org> --format json --from <RFC3339> --to <RFC3339>
+
+# Query selected Neki shards and pods
+pscale logs <database> <branch> --org <org> --format json --shard <shard> --server <pod>
+
+# Fetch the next page (100 entries per page by default)
+pscale logs <database> <branch> --org <org> --format json --page 2
+```
+
+| Flag | Purpose |
+|------|---------|
+| `--query` | Text or LogsQL expression; pipeline stages after `\|` are preserved |
+| `--period` | `15m`, `1h` (default), `3h`, `6h`, `12h`, `1d`, `7d`, or `8d` |
+| `--from` | Start of a custom ISO 8601 time range; must be used with `--to` and cannot be combined with `--period` |
+| `--to` | End of a custom ISO 8601 time range; must be used with `--from` and cannot be combined with `--period` |
+| `--level` | Comma-separated or repeatable `DEBUG`, `INFO`, `WARNING`, or `ERROR` filters |
+| `--server` | Comma-separated or repeatable server filters; `primary` (default) selects the primary role, other values select pod names |
+| `--shard` | Comma-separated or repeatable Neki shard filters |
+| `--limit` | Maximum entries per page (default `100`) |
+| `--page` | Page number; translated to a LogsQL offset (default `1`) |
+
+Human output prints one event per line as `<time> <level> <message>`, escaping embedded newlines and tabs. Success JSON is an array of parsed entries with `time`, `level`, `message`, `role`, `shard`, `container`, `availability_zone`, `pod`, `stream_id`, and `raw_message`. Malformed individual log lines are skipped. PostgreSQL and Neki branches are supported; other engines return `NOT_FOUND` from the signature endpoint.
+
 ## Metrics
 
 Query historical or current branch metrics through the public metrics API:
@@ -522,9 +557,9 @@ pscale branch switchover show <database> <branch> <id> --org <org> --format json
 - A switchover that ends in `failed` has an unconfirmed outcome: the primary may still have moved and nothing is rolled back. Check the current primary with `pscale branch infra <database> <branch> --org <org> --format json` before retrying.
 - `--candidate` is rejected for branches without replicas. Poll status with `pscale branch switchover show <database> <branch> <id> --org <org> --format json`.
 
-## Postgres branch maintenance
+## Branch maintenance
 
-`pscale branch maintenance run` upgrades a Postgres branch to the latest cluster image. This is how regular version bumps, bugfixes, and quality-of-life improvements reach a branch; PlanetScale otherwise upgrades images only in emergencies, such as patching security issues.
+`pscale branch maintenance run` upgrades a Postgres or Neki branch to the latest cluster image. This is how regular version bumps, bugfixes, and quality-of-life improvements reach a branch; PlanetScale otherwise upgrades images only in emergencies, such as patching security issues.
 
 ```bash
 # Run maintenance now
@@ -535,12 +570,194 @@ pscale branch maintenance run <database> <branch> --org <org> --format json --up
 ```
 
 - The upgrade is applied to the replicas first, followed by a switchover from the old primary to an upgraded replica. That failover leads to a short period of database unavailability (seconds) and terminates all direct connections. A branch running a single instance has no replica to switch over to and is unavailable until it comes back. Warn the user before running this.
-- The command returns `{"result": "maintenance started", "branch": "<branch>"}` and exits; it does not wait. Check progress with `pscale branch infra <database> <branch> --org <org> --format json`.
+- The command returns `{"result": "maintenance started", "database": "<database>", "branch": "<branch>"}` and exits; it does not wait. Check progress with `pscale branch infra <database> <branch> --org <org> --format json`.
 - Rejected while a change request from `pscale branch resize` is still in progress — check `pscale branch resize status` first.
 - `--update-postgres-minor-version` is rejected when the branch is already on the latest minor version or the upgrade is unavailable for it.
-- Postgres only; Vitess/MySQL databases are rejected before any API call.
+- Postgres and Neki only; Vitess/MySQL databases are rejected before any API call.
 - See https://planetscale.com/docs/postgres/operations-philosophy
 
+## Neki data topology
+
+Neki branches expose their cluster-wide data topology through the branch resource:
+
+```bash
+# Read the cached data topology and its last synchronization time
+pscale branch data-topology get <database> <branch> --org <org> --format json
+
+# Show database, table, shard-group, shard-index, key-range, and shard relationships
+pscale branch data-topology ls <database> <branch> --org <org> --format json
+
+# Group the topology by physical shard and list the data hosted by each placement
+pscale branch data-topology ls <database> <branch> --org <org> --shards --format json
+
+# Replace the data topology using a JSON object from standard input
+pscale branch data-topology update <database> <branch> --org <org> --format json < data-topology.json
+```
+
+- `ls` JSON output uses the topology's structured `databases`, `shard_groups`, and `shard_indexes` domains. Human output renders the relationships as a tree.
+  The `--shards` option reverses the view to physical shard → shard-group key range → hosted data; its JSON output is keyed by shard UID and uses structured
+  placements, key ranges, tables, reference tables, and sequences.
+- `update` reads the topology from standard input.
+- `--format json` controls command output; it does not describe the input format.
+- The input must be a JSON object. Empty input, arrays, scalar values, and malformed JSON are rejected before the API request.
+- `get` returns the API's cached topology with `synced_at`. When the cached value is stale, the API schedules a refresh asynchronously, so the response may briefly contain the previous topology.
+- The command is only supported for Neki branches. Other branches return `NOT_FOUND`.
+
+## Neki shards
+
+Use `pscale branch shard` to manage the physical shards of a Neki branch:
+
+```bash
+# List every shard, or focus the list on one configuration profile
+pscale branch shard list <database> <branch> --org <org> --format json
+pscale branch shard list <database> <branch> --org <org> --config-profile <profile> --format json
+
+# Show one shard (includes whether it is the authoritative copy)
+pscale branch shard show <database> <branch> <shard-id> --org <org> --format json
+
+# Create shards in a configuration profile (--count defaults to 1)
+pscale branch shard create <database> <branch> --org <org> --config-profile <profile> --count 2 --format json
+
+# Move existing shards to a configuration profile
+pscale branch shard assign <database> <branch> <shard-id>... --org <org> --config-profile <profile> --format json
+
+# Set or clear a shard's display name
+pscale branch shard update <database> <branch> <shard-id> --org <org> --display-name reporting --format json
+pscale branch shard update <database> <branch> <shard-id> --org <org> --display-name "" --format json
+
+# Delete after explicit user approval
+pscale branch shard delete <database> <branch> <shard-id> --org <org> --force --format json
+```
+
+- `list` and `show` include `authoritative` — whether the shard is the authoritative copy from the branch data topology.
+- `list` accepts `--query`, `--page`, and `--per-page`. Use `--exclude-config-profile <profile>` to omit shards assigned to one profile.
+- `assign` returns one result per shard with `status` set to `assigned`, `unchanged`, or `failed`. A response can contain both successful and failed assignments, so inspect every result.
+- Assigning a shard reconciles it toward the target configuration profile's infrastructure settings.
+- `delete` is destructive. Ask the user to approve the exact shard before adding `--force`.
+
+## Neki configuration profiles
+
+Use `pscale branch config-profile` to manage the infrastructure configuration shared by a set of Neki shards:
+
+```bash
+# Discover profiles and inspect the current default
+pscale branch config-profile list <database> <branch> --org <org> --format json
+pscale branch config-profile show <database> <branch> <profile> --org <org> --format json
+pscale branch config-profile default <database> <branch> --org <org> --format json
+
+# Create or update a profile
+pscale branch config-profile create <database> <branch> <profile> --org <org> --cluster-size <size> --replicas 2 --format json
+pscale branch config-profile create <database> <branch> <profile> --org <org> --min-storage 10737418240 --max-storage 107374182400 --storage-autoscaling --format json
+pscale branch config-profile update <database> <branch> <profile> --org <org> --cluster-size <size> --replicas 2 --format json
+pscale branch config-profile update <database> <branch> <profile> --org <org> --parameters pgconf.max_connections=200 --format json
+pscale branch config-profile update <database> <branch> <profile> --org <org> --min-storage 21474836480 --storage-autoscaling=false --format json
+
+# Select the default used for new shards
+pscale branch config-profile set-default <database> <branch> <profile> --org <org> --format json
+
+# Inspect available settings and asynchronous changes
+pscale branch config-profile parameters <database> <branch> <profile> --org <org> --format json
+pscale branch config-profile extensions <database> <branch> <profile> --org <org> --format json
+pscale branch config-profile extensions enable <database> <branch> <profile> <extension> --org <org> --format json
+pscale branch config-profile extensions disable <database> <branch> <profile> <extension> --org <org> --format json
+pscale branch config-profile changes list <database> <branch> <profile> --org <org> --format json
+pscale branch config-profile changes show <database> <branch> <profile> <change-id> --org <org> --format json
+pscale branch config-profile changes cancel <database> <branch> <profile> <change-id> --org <org> --format json
+
+# Run maintenance on one profile or several
+pscale branch config-profile maintenance <database> <branch> <profile> --org <org> --format json
+pscale branch config-profile maintenance <database> <branch> <profile> <profile> --org <org> --format json
+
+# Delete after explicit user approval
+pscale branch config-profile delete <database> <branch> <profile> --org <org> --force --format json
+```
+
+- Create and update flags are optional in the API request unless explicitly supplied. Repeat `--parameters namespace.name=value` to update multiple settings together.
+- Storage flags are `--min-storage` and `--max-storage` in bytes, `--storage-autoscaling`, `--storage-iops`, and `--storage-throughput` (MiB/s). `list` and `show` include the current storage configuration.
+- `parameters` accepts `--namespace`, `--extension`, and `--internal` filters.
+- `extensions enable` / `extensions disable` toggle an extension that the catalog marks as enablable. Not every listed extension can be toggled.
+- Updates may create asynchronous change requests. Use `changes list` to inspect their state and `changes show` to see human-readable before → after differences, including storage; `changes cancel` cancels a request that is still cancelable.
+- `maintenance` upgrades one or more profiles to the latest image. It returns immediately; check profile `state` and `changes list` for progress. Warn the user about a short unavailability window before running it. Use `pscale branch maintenance run` to maintain every profile on the branch.
+- `delete` is destructive. Ask the user to approve the exact configuration profile before adding `--force`.
+
+## Neki routers
+
+Use `pscale branch router` to manage router groups for a Neki branch.
+
+```bash
+# List routers, inspect one, and list available sizes
+pscale branch router list <database> <branch> --org <org> --format json
+pscale branch router show <database> <branch> <router> --org <org> --format json
+pscale branch router sizes <database> <branch> --org <org> --format json
+
+# Create or update a router
+pscale branch router create <database> <branch> <router> --org <org> --size NKR-5 --replicas-per-cell 1 --format json
+pscale branch router update <database> <branch> <router> --org <org> --size NKR-10 --replicas-per-cell 2 --format json
+pscale branch router update <database> <branch> <router> --org <org> --autoscaling --max-replicas-per-cell 4 --target-cpu-utilization 70 --format json
+pscale branch router update <database> <branch> <router> --org <org> --parameters router.replication-lag-tolerable-max=15m --format json
+
+# Inspect asynchronous changes
+pscale branch router changes list <database> <branch> <router> --org <org> --format json
+pscale branch router changes show <database> <branch> <router> <change-id> --org <org> --format json
+pscale branch router changes cancel <database> <branch> <router> <change-id> --org <org> --format json
+
+# Delete after explicit user approval
+pscale branch router delete <database> <branch> <router> --org <org> --force --format json
+```
+
+- `--size` is a billed SKU name (e.g. `NKR-5`). Underscores are also accepted. Use `router sizes` to list valid SKUs.
+- Updates are applied asynchronously; check router `state` and `changes list` for progress. `changes show` prints human-readable before → after differences; `changes cancel` cancels a request that is still cancelable.
+- `delete` is destructive. Ask the user to approve the exact router before adding `--force`.
+
+## Neki sidecars
+
+Use `pscale branch sidecar` to inspect and update the connection-pool sidecar for a Neki configuration profile. Sidecars are created and deleted with their profile; there is no create or delete command.
+
+```bash
+# List sidecars and inspect one (by sidecar ID or configuration profile name)
+pscale branch sidecar list <database> <branch> --org <org> --format json
+pscale branch sidecar show <database> <branch> <sidecar> --org <org> --format json
+
+# Update parameters (repeat --parameters)
+pscale branch sidecar update <database> <branch> <sidecar> --org <org> --parameters pgbouncer.default_pool_size=20 --format json
+
+# Inspect available settings and asynchronous changes
+pscale branch sidecar parameters <database> <branch> <sidecar> --org <org> --format json
+pscale branch sidecar changes list <database> <branch> <sidecar> --org <org> --format json
+pscale branch sidecar changes show <database> <branch> <sidecar> <change-id> --org <org> --format json
+pscale branch sidecar changes cancel <database> <branch> <sidecar> <change-id> --org <org> --format json
+```
+
+- Each configuration profile has one sidecar. Pass the sidecar ID from `pscale branch sidecar list`, or the configuration profile name.
+- `--parameters` is required on `update`. Repeat `--parameters namespace.name=value` to change multiple settings together.
+- Updates are applied asynchronously; check sidecar `state` and `changes list` for progress. `changes show` prints human-readable before → after differences; `changes cancel` cancels a request that is still cancelable.
+- Sidecars cannot be created or deleted through the CLI or API.
+
+## Neki admin
+
+Use `pscale branch admin` to inspect and update the failover and recovery admin for a Neki branch. Each cluster has one admin, created and deleted with the cluster; there is no create, delete, or list command.
+
+```bash
+# Inspect the admin and list available sizes
+pscale branch admin show <database> <branch> --org <org> --format json
+pscale branch admin sizes <database> <branch> --org <org> --format json
+
+# Update size and parameters (repeat --parameters)
+pscale branch admin update <database> <branch> --org <org> --size NKA-0 --format json
+pscale branch admin update <database> <branch> --org <org> --parameters admin.recovery-poll-interval=20s --format json
+
+# Inspect available settings and asynchronous changes
+pscale branch admin parameters <database> <branch> --org <org> --format json
+pscale branch admin changes list <database> <branch> --org <org> --format json
+pscale branch admin changes show <database> <branch> <change-id> --org <org> --format json
+pscale branch admin changes cancel <database> <branch> <change-id> --org <org> --format json
+```
+
+- `--size` is a billed SKU name (e.g. `NKA-0`), not a Singularity slug. Underscores are also accepted. Use `admin sizes` to list valid SKUs.
+- At least one of `--size` or `--parameters` is required on `update`. Repeat `--parameters namespace.name=value` to change multiple settings together.
+- Updates are applied asynchronously; check admin `state` and `changes list` for progress. `changes show` prints human-readable before → after differences; `changes cancel` cancels a request that is still cancelable.
+- The admin cannot be created or deleted through the CLI or API.
+
 ## Billing payment methods
 
 Update the organization's card through Stripe-hosted Checkout. The CLI never collects PAN; the human must finish Checkout in a browser. There is only one current card.
@@ -615,6 +832,31 @@ pscale billing invoice line-items <invoice-id> --org <org> --format json
 - JSON preserves the API objects. Line items include the billed database and nested resource (usually a branch).
 - Requires `read_invoices` on a service token.
 
+## Neki backup restore
+
+Restoring a Neki backup creates a new branch. Configuration profiles and routers are restored; omitted sizes inherit the source. Sidecar, admin, and parameter settings are not restored.
+
+```bash
+# Preview the live source sizes restore will use if you send no overrides
+pscale backup restore show <database> <source-branch> <backup> --org <org> --format json
+
+# Restore and inherit source sizes
+pscale backup restore <database> <new-branch> <backup> --org <org> --format json
+pscale branch create <database> <new-branch> --org <org> --format json --restore <backup>
+
+# Override individual configuration profiles and routers (repeatable)
+pscale backup restore <database> <new-branch> <backup> --org <org> --format json \
+  --config-profile name=default,cluster-size=PS_40,replicas=2 \
+  --config-profile name=analytics,replicas=0 \
+  --router name=default,size=NKR_20,replicas-per-cell=1
+```
+
+- `--config-profile` is `name=<profile>[,cluster-size=<size>][,replicas=<n>]`. `--router` is `name=<router>[,size=<sku>][,replicas-per-cell=<n>]`. `name` is required; size and replica count are optional per entry.
+- `backup restore show` lists the source branch's current configuration profiles and routers. That is what an empty restore uses. It is live source state, not a snapshot stored on the backup.
+- `backup restore show` `<branch>` is the **source** branch the backup belongs to. `backup restore` `<branch>` is the **new** branch name.
+- `--cluster-size` is a shorthand for the default configuration profile. For Neki, `backup restore` omits it unless you pass it, so the source default is kept.
+- MySQL and PostgreSQL restores reject these flags. Profile and router parameters, admin size, and autoscaling are not accepted on restore.
+
 ## Imports (Cloudflare D1) — Postgres only
 
 `pscale import d1` migrates a Cloudflare D1 (SQLite) export into a PlanetScale Postgres branch. Every subcommand supports `--format json` and returns `status`, `issues`, and `next_steps`; stateful steps return a `migration_id` — pass it back with `--migration-id` to resume.
diff --git a/internal/cmd/admin/admin.go b/internal/cmd/admin/admin.go
new file mode 100644
index 000000000..0dfa5f478
--- /dev/null
+++ b/internal/cmd/admin/admin.go
@@ -0,0 +1,234 @@
+package admin
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/spf13/cobra"
+)
+
+func AdminCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "admin <command>",
+		Short: "Manage the admin config for a Neki database branch",
+		Long:  "Manage the admin config for a Neki database branch.\n\nEach cluster has one admin. The admin is created and deleted with the cluster. This command is only supported for Neki databases.",
+	}
+
+	cmd.AddCommand(
+		ChangesCmd(ch),
+		ParametersCmd(ch),
+		ShowCmd(ch),
+		SizesCmd(ch),
+		UpdateCmd(ch),
+	)
+
+	return cmd
+}
+
+type adminDisplay struct {
+	ID        string `header:"id" json:"id"`
+	Size      string `header:"size" json:"size"`
+	State     string `header:"state" json:"state"`
+	CreatedAt string `header:"created at" json:"created_at"`
+
+	orig *ps.NekiAdmin
+}
+
+func (a *adminDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(a.orig)
+}
+
+func (a *adminDisplay) MarshalCSVValue() interface{} {
+	return []*adminDisplay{a}
+}
+
+func toAdmin(admin *ps.NekiAdmin) *adminDisplay {
+	return &adminDisplay{
+		ID:        admin.ID,
+		Size:      adminSize(admin),
+		State:     admin.State,
+		CreatedAt: admin.CreatedAt.UTC().Format("2006-01-02 15:04:05"),
+		orig:      admin,
+	}
+}
+
+func adminSize(admin *ps.NekiAdmin) string {
+	if admin.SKU != nil {
+		if admin.SKU.DisplayName != "" {
+			return admin.SKU.DisplayName
+		}
+		if admin.SKU.Name != "" {
+			return admin.SKU.Name
+		}
+	}
+	return admin.AdminSize
+}
+
+func changeSize(name, displayName string) string {
+	if displayName != "" {
+		return displayName
+	}
+	return name
+}
+
+type adminDetailDisplay struct {
+	*adminDisplay
+
+	parameters []*ps.NekiParameter
+}
+
+func (a *adminDetailDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		*ps.NekiAdmin
+		Parameters []*ps.NekiParameter `json:"parameters"`
+	}{NekiAdmin: a.orig, Parameters: a.parameters})
+}
+
+func toAdminDetail(admin *ps.NekiAdmin, parameters []*ps.NekiParameter) *adminDetailDisplay {
+	return &adminDetailDisplay{adminDisplay: toAdmin(admin), parameters: parameters}
+}
+
+type parameterDisplay struct {
+	Namespace string `header:"namespace" json:"namespace"`
+	Name      string `header:"name" json:"name"`
+	Value     string `header:"value" json:"value"`
+	Default   string `header:"default" json:"default_value"`
+	Type      string `header:"type" json:"parameter_type"`
+	Restart   bool   `header:"restart" json:"restart"`
+
+	orig *ps.NekiParameter
+}
+
+func (p *parameterDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(p.orig)
+}
+
+func (p *parameterDisplay) MarshalCSVValue() interface{} {
+	return []*parameterDisplay{p}
+}
+
+func toParameters(parameters []*ps.NekiParameter) []*parameterDisplay {
+	out := make([]*parameterDisplay, 0, len(parameters))
+	for _, parameter := range parameters {
+		out = append(out, &parameterDisplay{
+			Namespace: parameter.Namespace,
+			Name:      parameter.Name,
+			Value:     formatValue(parameter.Value),
+			Default:   formatValue(parameter.DefaultValue),
+			Type:      parameter.ParameterType,
+			Restart:   parameter.Restart,
+			orig:      parameter,
+		})
+	}
+	return out
+}
+
+func formatValue(v interface{}) string {
+	switch value := v.(type) {
+	case nil:
+		return ""
+	case string:
+		return value
+	case float64:
+		return strconv.FormatFloat(value, 'f', -1, 64)
+	default:
+		return fmt.Sprintf("%v", value)
+	}
+}
+
+type changeDisplay struct {
+	ID        string `header:"id" json:"id"`
+	State     string `header:"state" json:"state"`
+	Changes   string `header:"changes" json:"changes"`
+	CreatedAt string `header:"created at" json:"created_at"`
+	orig      *ps.NekiAdminChange
+}
+
+func (c *changeDisplay) MarshalJSON() ([]byte, error) { return json.Marshal(c.orig) }
+func (c *changeDisplay) MarshalCSVValue() interface{} { return []*changeDisplay{c} }
+
+func toChange(c *ps.NekiAdminChange) *changeDisplay {
+	return &changeDisplay{
+		ID:        c.ID,
+		State:     c.State,
+		Changes:   formatChangeSummary(c),
+		CreatedAt: c.CreatedAt.UTC().Format("2006-01-02 15:04:05"),
+		orig:      c,
+	}
+}
+
+func formatChangeSummary(change *ps.NekiAdminChange) string {
+	differences := changeDifferences(change)
+	if len(differences) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(differences))
+	for _, difference := range differences {
+		parts = append(parts, fmt.Sprintf("%s: %s → %s", difference.Field, difference.Before, difference.After))
+	}
+	return strings.Join(parts, ", ")
+}
+
+func toChanges(changes []*ps.NekiAdminChange) []*changeDisplay {
+	out := make([]*changeDisplay, 0, len(changes))
+	for _, change := range changes {
+		out = append(out, toChange(change))
+	}
+	return out
+}
+
+type changeDifference struct {
+	Field  string
+	Before string
+	After  string
+}
+
+func changeDifferences(change *ps.NekiAdminChange) []changeDifference {
+	differences := make([]changeDifference, 0)
+	before := changeSize(change.PreviousAdminSize, change.PreviousAdminSizeDisplayName)
+	after := changeSize(change.AdminSize, change.AdminSizeDisplayName)
+	if before != after {
+		differences = append(differences, changeDifference{Field: "Size", Before: before, After: after})
+	}
+
+	parameterKeys := make(map[string]struct{})
+	for namespace, parameters := range change.PreviousParameters {
+		for name := range parameters {
+			parameterKeys[namespace+"."+name] = struct{}{}
+		}
+	}
+	for namespace, parameters := range change.Parameters {
+		for name := range parameters {
+			parameterKeys[namespace+"."+name] = struct{}{}
+		}
+	}
+
+	keys := make([]string, 0, len(parameterKeys))
+	for key := range parameterKeys {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	for _, key := range keys {
+		namespace, name, _ := strings.Cut(key, ".")
+		before, hadBefore := change.PreviousParameters[namespace][name]
+		after, hasAfter := change.Parameters[namespace][name]
+		if hadBefore && hasAfter && before == after {
+			continue
+		}
+		if !hadBefore {
+			before = "(default)"
+		}
+		if !hasAfter {
+			after = "(default)"
+		}
+		differences = append(differences, changeDifference{Field: "Parameter " + key, Before: before, After: after})
+	}
+
+	return differences
+}
diff --git a/internal/cmd/admin/admin_test.go b/internal/cmd/admin/admin_test.go
new file mode 100644
index 000000000..ab4618f07
--- /dev/null
+++ b/internal/cmd/admin/admin_test.go
@@ -0,0 +1,364 @@
+package admin
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/config"
+	"github.com/planetscale/cli/internal/mock"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+func adminTestHelper(svc ps.NekiAdminsService, out *bytes.Buffer) *cmdutil.Helper {
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(out)
+	return &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiAdmins: svc}, nil
+		},
+	}
+}
+
+func testAdmin() *ps.NekiAdmin {
+	return &ps.NekiAdmin{
+		Type:      "NekiAdmin",
+		ID:        "admin-1",
+		SKU:       &ps.NekiAdminSKU{Name: "NKA_0", DisplayName: "NKA-0"},
+		AdminSize: "NKA_0",
+		State:     "ready",
+		CreatedAt: time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+		UpdatedAt: time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+	}
+}
+
+func TestAdminShowCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiAdminsService{
+		GetFn: func(_ context.Context, req *ps.GetNekiAdminRequest) (*ps.NekiAdmin, error) {
+			c.Assert(req, qt.DeepEquals, &ps.GetNekiAdminRequest{
+				Organization: "acme",
+				Database:     "app",
+				Branch:       "main",
+			})
+			return testAdmin(), nil
+		},
+		ListParametersFn: func(_ context.Context, req *ps.ListNekiAdminParametersRequest) ([]*ps.NekiParameter, error) {
+			c.Assert(req, qt.DeepEquals, &ps.ListNekiAdminParametersRequest{
+				Organization: "acme",
+				Database:     "app",
+				Branch:       "main",
+			})
+			return []*ps.NekiParameter{{
+				Name:          "recovery-poll-interval",
+				Namespace:     "admin",
+				ParameterType: "time",
+				DefaultValue:  "10s",
+				Value:         "20s",
+			}}, nil
+		},
+	}
+
+	cmd := ShowCmd(adminTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.GetFnInvoked, qt.IsTrue)
+	c.Assert(svc.ListParametersFnInvoked, qt.IsTrue)
+	var detail map[string]interface{}
+	c.Assert(json.Unmarshal(out.Bytes(), &detail), qt.IsNil)
+	c.Assert(detail["id"], qt.Equals, "admin-1")
+	c.Assert(detail["admin_size"], qt.Equals, "NKA_0")
+	parameters := detail["parameters"].([]interface{})
+	c.Assert(parameters, qt.HasLen, 1)
+	c.Assert(parameters[0].(map[string]interface{})["name"], qt.Equals, "recovery-poll-interval")
+}
+
+func TestAdminShowHumanHeadersAndUTC(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	admin := testAdmin()
+	admin.CreatedAt = time.Date(2026, 8, 4, 12, 0, 0, 0, time.FixedZone("MDT", -6*60*60))
+	svc := &mock.NekiAdminsService{
+		GetFn: func(context.Context, *ps.GetNekiAdminRequest) (*ps.NekiAdmin, error) {
+			return admin, nil
+		},
+		ListParametersFn: func(context.Context, *ps.ListNekiAdminParametersRequest) ([]*ps.NekiParameter, error) {
+			return nil, nil
+		},
+	}
+	ch := &cmdutil.Helper{Printer: p, Config: &config.Config{Organization: "acme"}, Client: func() (*ps.Client, error) {
+		return &ps.Client{NekiAdmins: svc}, nil
+	}}
+
+	cmd := ShowCmd(ch)
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "ID")
+	c.Assert(out.String(), qt.Contains, "SIZE")
+	c.Assert(out.String(), qt.Contains, "STATE")
+	c.Assert(out.String(), qt.Contains, "CREATED AT")
+	c.Assert(out.String(), qt.Contains, "admin-1")
+	c.Assert(out.String(), qt.Contains, "NKA-0")
+	c.Assert(out.String(), qt.Contains, "2026-08-04 18:00:00")
+}
+
+func TestAdminUpdateCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiAdminsService{UpdateFn: func(_ context.Context, req *ps.UpdateNekiAdminRequest) (*ps.NekiAdmin, error) {
+		c.Assert(req.Organization, qt.Equals, "acme")
+		c.Assert(req.Database, qt.Equals, "app")
+		c.Assert(req.Branch, qt.Equals, "main")
+		c.Assert(*req.AdminSize, qt.Equals, "NKA_1")
+		c.Assert(req.Parameters, qt.DeepEquals, map[string]map[string]string{
+			"admin": {"recovery-poll-interval": "20s"},
+		})
+		return testAdmin(), nil
+	}}
+
+	cmd := UpdateCmd(adminTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "--size", "NKA-1", "--parameters", "admin.recovery-poll-interval=20s"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.UpdateFnInvoked, qt.IsTrue)
+}
+
+func TestAdminUpdateCmdRequiresFlag(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiAdminsService{}
+
+	cmd := UpdateCmd(adminTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main"})
+	err := cmd.Execute()
+	c.Assert(err, qt.ErrorMatches, "at least one of --size or --parameters is required")
+	c.Assert(svc.UpdateFnInvoked, qt.IsFalse)
+}
+
+func TestAdminUpdateCmdInvalidParameters(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiAdminsService{}
+
+	cmd := UpdateCmd(adminTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "--parameters", "bogus"})
+	err := cmd.Execute()
+	c.Assert(err, qt.ErrorMatches, `invalid --parameters "bogus": expected namespace.name=value`)
+}
+
+func TestAdminParametersCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiAdminsService{ListParametersFn: func(_ context.Context, req *ps.ListNekiAdminParametersRequest) ([]*ps.NekiParameter, error) {
+		c.Assert(req, qt.DeepEquals, &ps.ListNekiAdminParametersRequest{Organization: "acme", Database: "app", Branch: "main"})
+		return []*ps.NekiParameter{
+			{Name: "recovery-poll-interval", Namespace: "admin", Value: "20s"},
+		}, nil
+	}}
+
+	cmd := ParametersCmd(adminTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, []map[string]interface{}{{
+		"name": "recovery-poll-interval", "display_name": "", "namespace": "admin", "advanced": false,
+		"category": nil, "description": "", "parameter_type": "", "default_value": nil, "value": "20s",
+		"required": false, "created_at": "0001-01-01T00:00:00Z", "updated_at": nil, "restart": false, "url": "",
+	}})
+}
+
+func TestAdminChangesCancelCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiAdminsService{CancelChangeFn: func(_ context.Context, req *ps.CancelNekiAdminChangeRequest) error {
+		c.Assert(req, qt.DeepEquals, &ps.CancelNekiAdminChangeRequest{Organization: "acme", Database: "app", Branch: "main", Change: "change-1"})
+		return nil
+	}}
+
+	cmd := changesCancelCmd(adminTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "change-1"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"result": "change canceled", "change_id": "change-1",
+	})
+}
+
+func TestAdminChangesListHumanDisplaysDifferences(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	svc := &mock.NekiAdminsService{ListChangesFn: func(_ context.Context, req *ps.ListNekiAdminChangesRequest) ([]*ps.NekiAdminChange, error) {
+		c.Assert(req, qt.DeepEquals, &ps.ListNekiAdminChangesRequest{
+			Organization: "acme",
+			Database:     "app",
+			Branch:       "main",
+			PerPage:      100,
+		})
+		return []*ps.NekiAdminChange{{
+			ID:                           "change-1",
+			State:                        "completed",
+			CreatedAt:                    time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+			AdminSize:                    "NKA_1",
+			AdminSizeDisplayName:         "NKA-1",
+			PreviousAdminSize:            "NKA_0",
+			PreviousAdminSizeDisplayName: "NKA-0",
+			Parameters: map[string]map[string]string{"admin": {
+				"recovery-poll-interval": "20s",
+			}},
+			PreviousParameters: map[string]map[string]string{"admin": {
+				"recovery-poll-interval":     "10s",
+				"planned-switchover-timeout": "1m",
+			}},
+		}}, nil
+	}}
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiAdmins: svc}, nil
+		},
+	}
+
+	cmd := changesListCmd(ch)
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "CHANGES")
+	c.Assert(out.String(), qt.Contains, "NKA-0")
+	c.Assert(out.String(), qt.Contains, "NKA-1")
+	c.Assert(out.String(), qt.Contains, "admin.recovery-poll-interval")
+	c.Assert(out.String(), qt.Contains, "admin.planned-switchover-timeout")
+}
+
+func TestFormatChangeSummary(t *testing.T) {
+	c := qt.New(t)
+	got := formatChangeSummary(&ps.NekiAdminChange{
+		AdminSize:                    "NKA_1",
+		AdminSizeDisplayName:         "NKA-1",
+		PreviousAdminSize:            "NKA_0",
+		PreviousAdminSizeDisplayName: "NKA-0",
+		Parameters: map[string]map[string]string{"admin": {
+			"recovery-poll-interval": "20s",
+		}},
+		PreviousParameters: map[string]map[string]string{"admin": {
+			"recovery-poll-interval":     "10s",
+			"planned-switchover-timeout": "1m",
+		}},
+	})
+	c.Assert(got, qt.Contains, "Size: NKA-0 → NKA-1")
+	c.Assert(got, qt.Contains, "Parameter admin.recovery-poll-interval: 10s → 20s")
+	c.Assert(got, qt.Contains, "Parameter admin.planned-switchover-timeout: 1m → (default)")
+}
+
+func TestAdminChangesShowHumanDisplaysDifferences(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	svc := &mock.NekiAdminsService{GetChangeFn: func(_ context.Context, req *ps.GetNekiAdminChangeRequest) (*ps.NekiAdminChange, error) {
+		c.Assert(req, qt.DeepEquals, &ps.GetNekiAdminChangeRequest{
+			Organization: "acme",
+			Database:     "app",
+			Branch:       "main",
+			Change:       "change-1",
+		})
+		return &ps.NekiAdminChange{
+			ID:                           "change-1",
+			State:                        "applying",
+			CreatedAt:                    time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+			AdminSize:                    "NKA_1",
+			AdminSizeDisplayName:         "NKA-1",
+			PreviousAdminSize:            "NKA_0",
+			PreviousAdminSizeDisplayName: "NKA-0",
+			Parameters: map[string]map[string]string{"admin": {
+				"recovery-poll-interval": "20s",
+			}},
+			PreviousParameters: map[string]map[string]string{"admin": {
+				"recovery-poll-interval":     "10s",
+				"planned-switchover-timeout": "1m",
+			}},
+		}, nil
+	}}
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiAdmins: svc}, nil
+		},
+	}
+
+	cmd := changesShowCmd(ch)
+	cmd.SetArgs([]string{"app", "main", "change-1"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "Changes:")
+	c.Assert(out.String(), qt.Contains, "Size: NKA-0 → NKA-1")
+	c.Assert(out.String(), qt.Contains, "Parameter admin.recovery-poll-interval: 10s → 20s")
+	c.Assert(out.String(), qt.Contains, "Parameter admin.planned-switchover-timeout: 1m → (default)")
+}
+
+func TestAdminSizesCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiAdminsService{ListSizeSKUsFn: func(_ context.Context, req *ps.ListNekiAdminSizeSKUsRequest) ([]*ps.NekiAdminSKU, error) {
+		c.Assert(req, qt.DeepEquals, &ps.ListNekiAdminSizeSKUsRequest{
+			Organization: "acme",
+			Database:     "app",
+			Branch:       "main",
+		})
+		return []*ps.NekiAdminSKU{{
+			Name:        "NKA_0",
+			DisplayName: "NKA-0",
+			CPU:         "0.5",
+			RAM:         1073741824,
+			SortOrder:   1,
+		}}, nil
+	}}
+
+	cmd := SizesCmd(adminTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.ListSizeSKUsFnInvoked, qt.IsTrue)
+	c.Assert(out.String(), qt.JSONEquals, []map[string]interface{}{{
+		"name":         "NKA_0",
+		"display_name": "NKA-0",
+		"cpu":          "0.5",
+		"ram":          float64(1073741824),
+		"sort_order":   float64(1),
+	}})
+}
+
+func TestAdminCmdSubcommands(t *testing.T) {
+	cmd := AdminCmd(&cmdutil.Helper{Config: &config.Config{}})
+	for _, name := range []string{"changes", "parameters", "show", "sizes", "update"} {
+		found, _, err := cmd.Find([]string{name})
+		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, found.Name(), qt.Equals, name)
+	}
+
+	changes, _, err := cmd.Find([]string{"changes"})
+	qt.Assert(t, err, qt.IsNil)
+	for _, name := range []string{"cancel", "list", "show"} {
+		found, _, err := changes.Find([]string{name})
+		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, found.Name(), qt.Equals, name)
+	}
+
+	for _, sub := range cmd.Commands() {
+		qt.Assert(t, sub.Name() == "create" || sub.Name() == "delete" || sub.Name() == "list", qt.IsFalse)
+	}
+}
diff --git a/internal/cmd/admin/changes.go b/internal/cmd/admin/changes.go
new file mode 100644
index 000000000..212b6adee
--- /dev/null
+++ b/internal/cmd/admin/changes.go
@@ -0,0 +1,154 @@
+package admin
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ChangesCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "changes <command>",
+		Short: "Manage changes to a Neki admin",
+	}
+	cmd.AddCommand(changesListCmd(ch), changesShowCmd(ch), changesCancelCmd(ch))
+	return cmd
+}
+
+func changesListCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		period      string
+		completedAt string
+		page        int
+		perPage     int
+	}
+
+	cmd := &cobra.Command{
+		Use:     "list <database> <branch>",
+		Short:   "List changes for a Neki admin",
+		Args:    cmdutil.ExactArgs("database", "branch"),
+		Aliases: []string{"ls"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching changes for the admin of %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+			changes, err := client.NekiAdmins.ListChanges(cmd.Context(), &ps.ListNekiAdminChangesRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Period:       flags.period,
+				CompletedAt:  flags.completedAt,
+				Page:         flags.page,
+				PerPage:      flags.perPage,
+			})
+			if err != nil {
+				return handleError(err, database, branch)
+			}
+			end()
+
+			if len(changes) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No changes found for the admin of %s/%s.\n", printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+			return ch.Printer.PrintResource(toChanges(changes))
+		},
+	}
+
+	cmd.Flags().StringVar(&flags.period, "period", "", "Only show changes from this period")
+	cmd.Flags().StringVar(&flags.completedAt, "completed-at", "", "Only show changes completed at this time")
+	cmd.Flags().IntVar(&flags.page, "page", 0, "Page number to fetch")
+	cmd.Flags().IntVar(&flags.perPage, "per-page", 100, "Number of results per page")
+	return cmd
+}
+
+func changesShowCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:     "show <database> <branch> <change-id>",
+		Short:   "Show a change to a Neki admin",
+		Args:    cmdutil.ExactArgs("database", "branch", "change-id"),
+		Aliases: []string{"get"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, changeID := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching change %s", printer.BoldBlue(changeID)))
+			defer end()
+			change, err := client.NekiAdmins.GetChange(cmd.Context(), &ps.GetNekiAdminChangeRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Change:       changeID,
+			})
+			if err != nil {
+				return handleError(err, database, branch)
+			}
+			end()
+			if ch.Printer.Format() == printer.Human {
+				if err := ch.Printer.PrintResource(toChange(change)); err != nil {
+					return err
+				}
+
+				differences := changeDifferences(change)
+				if len(differences) == 0 {
+					ch.Printer.Println("No configuration differences.")
+					return nil
+				}
+
+				ch.Printer.Println("Changes:")
+				for _, difference := range differences {
+					ch.Printer.Printf("  %s: %s → %s\n", difference.Field, difference.Before, difference.After)
+				}
+				return nil
+			}
+			return ch.Printer.PrintResource(toChange(change))
+		},
+	}
+}
+
+func changesCancelCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:   "cancel <database> <branch> <change-id>",
+		Short: "Cancel a pending change to a Neki admin",
+		Args:  cmdutil.ExactArgs("database", "branch", "change-id"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, changeID := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Cancelling change %s", printer.BoldBlue(changeID)))
+			defer end()
+			err = client.NekiAdmins.CancelChange(cmd.Context(), &ps.CancelNekiAdminChangeRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Change:       changeID,
+			})
+			if err != nil {
+				return handleError(err, database, branch)
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Canceled change %s for the admin of %s/%s.\n", printer.BoldBlue(changeID), printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+			return ch.Printer.PrintResource(map[string]string{
+				"result":    "change canceled",
+				"change_id": changeID,
+			})
+		},
+	}
+}
diff --git a/internal/cmd/admin/errors.go b/internal/cmd/admin/errors.go
new file mode 100644
index 000000000..d7e46188c
--- /dev/null
+++ b/internal/cmd/admin/errors.go
@@ -0,0 +1,18 @@
+package admin
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+func handleError(err error, database, branch string) error {
+	if cmdutil.ErrCode(err) != ps.ErrNotFound {
+		return cmdutil.HandleError(err)
+	}
+
+	return fmt.Errorf("database %s or branch %s does not exist, the branch is not a Neki branch, or it has no admin",
+		printer.BoldBlue(database), printer.BoldBlue(branch))
+}
diff --git a/internal/cmd/admin/parameters.go b/internal/cmd/admin/parameters.go
new file mode 100644
index 000000000..e35453507
--- /dev/null
+++ b/internal/cmd/admin/parameters.go
@@ -0,0 +1,49 @@
+package admin
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ParametersCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "parameters <database> <branch>",
+		Short:   "List parameters for a Neki admin",
+		Long:    "List parameters for a Neki admin.\n\nEach cluster has one admin.",
+		Args:    cmdutil.ExactArgs("database", "branch"),
+		Aliases: []string{"params"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching parameters for the admin of %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			parameters, err := client.NekiAdmins.ListParameters(cmd.Context(), &ps.ListNekiAdminParametersRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return handleError(err, database, branch)
+			}
+			end()
+
+			if len(parameters) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No parameters found for the admin of %s/%s.\n", printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(toParameters(parameters))
+		},
+	}
+
+	return cmd
+}
diff --git a/internal/cmd/admin/show.go b/internal/cmd/admin/show.go
new file mode 100644
index 000000000..577a198ac
--- /dev/null
+++ b/internal/cmd/admin/show.go
@@ -0,0 +1,64 @@
+package admin
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ShowCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "show <database> <branch>",
+		Short:   "Show the admin for a Neki database branch",
+		Long:    "Show the admin for a Neki database branch.\n\nEach cluster has one admin.",
+		Args:    cmdutil.ExactArgs("database", "branch"),
+		Aliases: []string{"get"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching admin for %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			resource, err := client.NekiAdmins.Get(cmd.Context(), &ps.GetNekiAdminRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return handleError(err, database, branch)
+			}
+
+			parameters, err := client.NekiAdmins.ListParameters(cmd.Context(), &ps.ListNekiAdminParametersRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return handleError(err, database, branch)
+			}
+			end()
+
+			if ch.Printer.Format() != printer.Human {
+				return ch.Printer.PrintResource(toAdminDetail(resource, parameters))
+			}
+
+			if err := ch.Printer.PrintResource(toAdmin(resource)); err != nil {
+				return err
+			}
+			if len(parameters) == 0 {
+				return nil
+			}
+			ch.Printer.Println()
+			return ch.Printer.PrintResource(toParameters(parameters))
+		},
+	}
+
+	return cmd
+}
diff --git a/internal/cmd/admin/sizes.go b/internal/cmd/admin/sizes.go
new file mode 100644
index 000000000..b6bdedfd3
--- /dev/null
+++ b/internal/cmd/admin/sizes.go
@@ -0,0 +1,82 @@
+package admin
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func SizesCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "sizes <database> <branch>",
+		Short:   "List available admin sizes for a Neki database branch",
+		Args:    cmdutil.ExactArgs("database", "branch"),
+		Aliases: []string{"size-skus"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching admin sizes for %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			skus, err := client.NekiAdmins.ListSizeSKUs(cmd.Context(), &ps.ListNekiAdminSizeSKUsRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return handleError(err, database, branch)
+			}
+			end()
+
+			if len(skus) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No admin sizes found for %s/%s.\n", printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(toAdminSKUs(skus))
+		},
+	}
+
+	return cmd
+}
+
+type adminSKUDisplay struct {
+	Name   string `header:"name" json:"name"`
+	CPU    string `header:"cpu" json:"cpu"`
+	Memory string `header:"memory" json:"memory"`
+
+	orig *ps.NekiAdminSKU
+}
+
+func (s *adminSKUDisplay) MarshalJSON() ([]byte, error) { return json.Marshal(s.orig) }
+func (s *adminSKUDisplay) MarshalCSVValue() interface{} { return []*adminSKUDisplay{s} }
+
+func toAdminSKU(sku *ps.NekiAdminSKU) *adminSKUDisplay {
+	name := sku.DisplayName
+	if name == "" {
+		name = cmdutil.ToClusterSizeSlug(sku.Name)
+	}
+
+	return &adminSKUDisplay{
+		Name:   name,
+		CPU:    sku.CPU,
+		Memory: cmdutil.FormatParts(sku.RAM).IntString(),
+		orig:   sku,
+	}
+}
+
+func toAdminSKUs(skus []*ps.NekiAdminSKU) []*adminSKUDisplay {
+	out := make([]*adminSKUDisplay, 0, len(skus))
+	for _, sku := range skus {
+		out = append(out, toAdminSKU(sku))
+	}
+	return out
+}
diff --git a/internal/cmd/admin/update.go b/internal/cmd/admin/update.go
new file mode 100644
index 000000000..10742b0a2
--- /dev/null
+++ b/internal/cmd/admin/update.go
@@ -0,0 +1,97 @@
+package admin
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func UpdateCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		size       string
+		parameters []string
+	}
+
+	cmd := &cobra.Command{
+		Use:   "update <database> <branch>",
+		Short: "Update the admin for a Neki database branch",
+		Long:  "Update the admin for a Neki database branch.\n\nChanges are requested and applied asynchronously; the admin state shows progress.",
+		Args:  cmdutil.ExactArgs("database", "branch"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+
+			changed := false
+			for _, flag := range []string{"size", "parameters"} {
+				changed = changed || cmd.Flags().Changed(flag)
+			}
+			if !changed {
+				return fmt.Errorf("at least one of --size or --parameters is required")
+			}
+
+			parameters, err := parseParameters(flags.parameters)
+			if err != nil {
+				return err
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Updating admin for %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			resource, err := client.NekiAdmins.Update(cmd.Context(), &ps.UpdateNekiAdminRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				AdminSize:    stringPointerIfChanged(cmd, "size", cmdutil.ToSizeSKUName(flags.size)),
+				Parameters:   parameters,
+			})
+			if err != nil {
+				return handleError(err, database, branch)
+			}
+			end()
+
+			return ch.Printer.PrintResource(toAdmin(resource))
+		},
+	}
+
+	cmd.Flags().StringVar(&flags.size, "size", "", "New admin size SKU (e.g. NKA-0)")
+	cmd.Flags().StringArrayVar(&flags.parameters, "parameters", nil, "Set a parameter as namespace.name=value; repeatable")
+
+	return cmd
+}
+
+func parseParameters(values []string) (map[string]map[string]string, error) {
+	if len(values) == 0 {
+		return nil, nil
+	}
+	out := make(map[string]map[string]string)
+	for _, value := range values {
+		key, setting, ok := strings.Cut(value, "=")
+		if !ok {
+			return nil, fmt.Errorf("invalid --parameters %q: expected namespace.name=value", value)
+		}
+		namespace, name, ok := strings.Cut(key, ".")
+		if !ok || namespace == "" || name == "" {
+			return nil, fmt.Errorf("invalid --parameters %q: expected namespace.name=value", value)
+		}
+		if out[namespace] == nil {
+			out[namespace] = make(map[string]string)
+		}
+		out[namespace][name] = setting
+	}
+	return out, nil
+}
+
+func stringPointerIfChanged(cmd *cobra.Command, name, value string) *string {
+	if !cmd.Flags().Changed(name) {
+		return nil
+	}
+	return &value
+}
diff --git a/internal/cmd/backup/backup.go b/internal/cmd/backup/backup.go
index aee428f31..d1f894fbb 100644
--- a/internal/cmd/backup/backup.go
+++ b/internal/cmd/backup/backup.go
@@ -16,7 +16,7 @@ import (
 func BackupCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:               "backup <command>",
-		Short:             "Manage branch backups and backup policies",
+		Short:             "Manage branch backups, backup policies, and restores",
 		PersistentPreRunE: cmdutil.CheckAuthentication(ch.Config),
 	}
 
diff --git a/internal/cmd/backup/restore.go b/internal/cmd/backup/restore.go
index 219ec04e7..08d3a1c21 100644
--- a/internal/cmd/backup/restore.go
+++ b/internal/cmd/backup/restore.go
@@ -17,11 +17,20 @@ func RestoreCmd(ch *cmdutil.Helper) *cobra.Command {
 		clusterSize string
 		replicas    int
 	}
+	var configProfiles []string
+	var routers []string
 
 	cmd := &cobra.Command{
-		Use:   "restore <database> <branch> <backup>",
+		Use:   "restore <database> <new-branch> <backup>",
 		Short: "Restore a backup to a new branch",
-		Args:  cmdutil.RequiredArgs("database", "branch", "backup"),
+		Long: `Restore a backup to a new branch.
+
+<new-branch> is the name of the branch to create. It must not already exist.
+The backup is identified by id; the source branch is not a restore argument.
+Preview Neki restore sizes from the source branch with:
+
+  pscale backup restore show <database> <source-branch> <backup>`,
+		Args: cmdutil.RequiredArgs("database", "new-branch", "backup"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
 			database := args[0]
@@ -47,6 +56,10 @@ func RestoreCmd(ch *cmdutil.Helper) *cobra.Command {
 				}
 			}
 
+			if err := cmdutil.EnsureNekiRestoreSizing(db.Kind, true, false, len(configProfiles) > 0 || len(routers) > 0); err != nil {
+				return err
+			}
+
 			end := ch.Printer.PrintProgress(fmt.Sprintf("Restoring backup %s to %s", printer.BoldBlue(backup), printer.BoldBlue(branchName)))
 			defer end()
 
@@ -69,17 +82,25 @@ func RestoreCmd(ch *cmdutil.Helper) *cobra.Command {
 				end()
 				return ch.Printer.PrintResource(branch.ToDatabaseBranch(newBranch))
 			} else {
+				clusterName := flags.clusterSize
+				if db.Kind == planetscale.DatabaseEngineNeki && !cmd.Flags().Changed("cluster-size") {
+					clusterName = ""
+				}
+
 				createReq := &planetscale.CreatePostgresBranchRequest{
 					Organization: ch.Config.Organization,
 					Database:     database,
 					Name:         branchName,
 					BackupID:     backup,
-					ClusterName:  flags.clusterSize,
+					ClusterName:  clusterName,
 				}
 				if cmd.Flags().Changed("replicas") {
 					replicas := flags.replicas
 					createReq.Replicas = &replicas
 				}
+				if err := cmdutil.ApplyNekiRestoreSizing(createReq, configProfiles, routers); err != nil {
+					return err
+				}
 
 				newBranch, err := client.PostgresBranches.Create(ctx, createReq)
 				if err != nil {
@@ -92,12 +113,15 @@ func RestoreCmd(ch *cmdutil.Helper) *cobra.Command {
 		},
 	}
 
-	cmd.Flags().StringVar(&flags.clusterSize, "cluster-size", "PS-10", "Cluster size for restored backup branch. Use `pscale size cluster list` to see the valid sizes.")
+	cmd.Flags().StringVar(&flags.clusterSize, "cluster-size", "PS-10", "Cluster size for restored backup branch. For Neki, omitted unless set so the source default profile size is used. Use `pscale size cluster list` to see the valid sizes.")
 	cmd.Flags().IntVar(&flags.replicas, "replicas", 0, "Number of additional replicas for a PostgreSQL restore. 0 creates a single-node branch; omit to use the target cluster size default.")
-	cmd.MarkFlagRequired("cluster-size")
+	cmd.Flags().StringArrayVar(&configProfiles, "config-profile", nil, cmdutil.ConfigProfileSizeFlagHelp)
+	cmd.Flags().StringArrayVar(&routers, "router", nil, cmdutil.RouterSizeFlagHelp)
 	cmd.RegisterFlagCompletionFunc("cluster-size", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		return cmdutil.ClusterSizesCompletionFunc(ch, cmd, args, toComplete)
 	})
 
+	cmd.AddCommand(RestoreShowCmd(ch))
+
 	return cmd
 }
diff --git a/internal/cmd/backup/restore_show.go b/internal/cmd/backup/restore_show.go
new file mode 100644
index 000000000..53051cfa9
--- /dev/null
+++ b/internal/cmd/backup/restore_show.go
@@ -0,0 +1,177 @@
+package backup
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/lensesio/tableprinter"
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func RestoreShowCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:   "show <database> <branch> <backup>",
+		Short: "Show the sizes a Neki backup restore will use if you do not override them",
+		Long: `Show the configuration profile and router sizes a Neki backup restore will use.
+
+These values come from the live source branch, the same source the dashboard
+pickers use. They are not stored on the backup. If the source branch was resized
+after the backup, this command shows the current sizes.
+
+<branch> is the source branch the backup belongs to, same as backup show.`,
+		Args: cmdutil.RequiredArgs("database", "branch", "backup"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+			database := args[0]
+			branch := args[1]
+			backup := args[2]
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			db, err := client.Databases.Get(ctx, &planetscale.GetDatabaseRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+			})
+			if err != nil {
+				switch cmdutil.ErrCode(err) {
+				case planetscale.ErrNotFound:
+					return fmt.Errorf("database %s does not exist in organization %s",
+						printer.BoldBlue(database), printer.BoldBlue(ch.Config.Organization))
+				default:
+					return cmdutil.HandleError(err)
+				}
+			}
+			if db.Kind != planetscale.DatabaseEngineNeki {
+				return fmt.Errorf("backup restore show is only supported for Neki databases")
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching restore defaults for backup %s on %s/%s", printer.BoldBlue(backup), printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			if _, err := client.Backups.Get(ctx, &planetscale.GetBackupRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Backup:       backup,
+			}); err != nil {
+				switch cmdutil.ErrCode(err) {
+				case planetscale.ErrNotFound:
+					return fmt.Errorf("backup %s does not exist in branch %s of %s (organization: %s)",
+						printer.BoldBlue(backup), printer.BoldBlue(branch), printer.BoldBlue(database), printer.BoldBlue(ch.Config.Organization))
+				default:
+					return cmdutil.HandleError(err)
+				}
+			}
+
+			profiles, err := client.NekiShardConfigurationProfiles.List(ctx, &planetscale.ListNekiShardConfigurationProfilesRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return cmdutil.HandleError(err)
+			}
+
+			routers, err := client.NekiRouters.List(ctx, &planetscale.ListNekiRoutersRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return cmdutil.HandleError(err)
+			}
+
+			end()
+			return printRestoreDefaults(ch, toRestoreDefaults(database, branch, backup, profiles, routers))
+		},
+	}
+}
+
+type restoreDefaultProfile struct {
+	Name        string `header:"name" json:"name"`
+	Default     bool   `header:"default" json:"default"`
+	ClusterSize string `header:"cluster size" json:"cluster_size"`
+	Replicas    int    `header:"replicas" json:"replicas"`
+}
+
+type restoreDefaultRouter struct {
+	Name            string `header:"name" json:"name"`
+	Default         bool   `header:"default" json:"default"`
+	Size            string `header:"size" json:"size"`
+	ReplicasPerCell int    `header:"replicas per cell" json:"replicas_per_cell"`
+}
+
+type restoreDefaults struct {
+	Database              string                  `json:"database"`
+	Branch                string                  `json:"branch"`
+	Backup                string                  `json:"backup"`
+	ConfigurationProfiles []restoreDefaultProfile `json:"configuration_profiles"`
+	Routers               []restoreDefaultRouter  `json:"routers"`
+}
+
+func toRestoreDefaults(database, branch, backup string, profiles []*planetscale.NekiShardConfigurationProfile, routers []*planetscale.NekiRouter) *restoreDefaults {
+	out := &restoreDefaults{
+		Database:              database,
+		Branch:                branch,
+		Backup:                backup,
+		ConfigurationProfiles: make([]restoreDefaultProfile, 0, len(profiles)),
+		Routers:               make([]restoreDefaultRouter, 0, len(routers)),
+	}
+	for _, profile := range profiles {
+		out.ConfigurationProfiles = append(out.ConfigurationProfiles, restoreDefaultProfile{
+			Name:        profile.Name,
+			Default:     profile.Default,
+			ClusterSize: profile.ClusterSize,
+			Replicas:    profile.Replicas,
+		})
+	}
+	for _, router := range routers {
+		size := ""
+		if router.SKU != nil {
+			size = router.SKU.Name
+			if router.SKU.DisplayName != "" {
+				size = router.SKU.DisplayName
+			}
+		}
+		out.Routers = append(out.Routers, restoreDefaultRouter{
+			Name:            router.Name,
+			Default:         router.Default,
+			Size:            size,
+			ReplicasPerCell: router.ReplicasPerCell,
+		})
+	}
+	return out
+}
+
+func printRestoreDefaults(ch *cmdutil.Helper, defaults *restoreDefaults) error {
+	if ch.Printer.Format() != printer.Human {
+		return ch.Printer.PrintResource(defaults)
+	}
+
+	ch.Printer.Printf("If backup %s is restored without --config-profile or --router, these live source sizes are used:\n\n", printer.BoldBlue(defaults.Backup))
+
+	var buf strings.Builder
+	if len(defaults.ConfigurationProfiles) == 0 {
+		ch.Printer.Println("Configuration profiles: none")
+	} else {
+		ch.Printer.Println("Configuration profiles")
+		tableprinter.Print(&buf, defaults.ConfigurationProfiles)
+		ch.Printer.Print(buf.String())
+	}
+
+	buf.Reset()
+	if len(defaults.Routers) == 0 {
+		ch.Printer.Println("Routers: none")
+	} else {
+		ch.Printer.Println("Routers")
+		tableprinter.Print(&buf, defaults.Routers)
+		ch.Printer.Print(buf.String())
+	}
+	return nil
+}
diff --git a/internal/cmd/backup/restore_show_test.go b/internal/cmd/backup/restore_show_test.go
new file mode 100644
index 000000000..c58edf719
--- /dev/null
+++ b/internal/cmd/backup/restore_show_test.go
@@ -0,0 +1,183 @@
+package backup
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/config"
+	"github.com/planetscale/cli/internal/mock"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+func TestBackup_RestoreShowCmd(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(&buf)
+
+	org := "planetscale"
+	db := "app"
+	branch := "main"
+	backup := "bak_123"
+
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			c.Assert(req.Organization, qt.Equals, org)
+			c.Assert(req.Database, qt.Equals, db)
+			return &ps.Database{Kind: ps.DatabaseEngineNeki}, nil
+		},
+	}
+	backupSvc := &mock.BackupsService{
+		GetFn: func(ctx context.Context, req *ps.GetBackupRequest) (*ps.Backup, error) {
+			c.Assert(req.Organization, qt.Equals, org)
+			c.Assert(req.Database, qt.Equals, db)
+			c.Assert(req.Branch, qt.Equals, branch)
+			c.Assert(req.Backup, qt.Equals, backup)
+			return &ps.Backup{Name: backup}, nil
+		},
+	}
+	profileSvc := &mock.NekiShardConfigurationProfilesService{
+		ListFn: func(ctx context.Context, req *ps.ListNekiShardConfigurationProfilesRequest) ([]*ps.NekiShardConfigurationProfile, error) {
+			c.Assert(req, qt.DeepEquals, &ps.ListNekiShardConfigurationProfilesRequest{
+				Organization: org,
+				Database:     db,
+				Branch:       branch,
+			})
+			return []*ps.NekiShardConfigurationProfile{
+				{Name: "default", Default: true, ClusterSize: "PS_40", Replicas: 2},
+				{Name: "analytics", ClusterSize: "PS_10", Replicas: 0},
+			}, nil
+		},
+	}
+	routerSvc := &mock.NekiRoutersService{
+		ListFn: func(ctx context.Context, req *ps.ListNekiRoutersRequest) ([]*ps.NekiRouter, error) {
+			c.Assert(req, qt.DeepEquals, &ps.ListNekiRoutersRequest{
+				Organization: org,
+				Database:     db,
+				Branch:       branch,
+			})
+			return []*ps.NekiRouter{
+				{
+					Name:            "default",
+					Default:         true,
+					SKU:             &ps.NekiRouterSKU{Name: "NKR_20", DisplayName: "NKR-20"},
+					ReplicasPerCell: 1,
+				},
+			}, nil
+		},
+	}
+
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: org},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{
+				Databases:                      dbSvc,
+				Backups:                        backupSvc,
+				NekiShardConfigurationProfiles: profileSvc,
+				NekiRouters:                    routerSvc,
+			}, nil
+		},
+	}
+
+	cmd := RestoreCmd(ch)
+	cmd.SetArgs([]string{"show", db, branch, backup})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(backupSvc.GetFnInvoked, qt.IsTrue)
+	c.Assert(profileSvc.ListFnInvoked, qt.IsTrue)
+	c.Assert(routerSvc.ListFnInvoked, qt.IsTrue)
+	c.Assert(buf.String(), qt.JSONEquals, map[string]any{
+		"database": db,
+		"branch":   branch,
+		"backup":   backup,
+		"configuration_profiles": []map[string]any{
+			{"name": "default", "default": true, "cluster_size": "PS_40", "replicas": float64(2)},
+			{"name": "analytics", "default": false, "cluster_size": "PS_10", "replicas": float64(0)},
+		},
+		"routers": []map[string]any{
+			{"name": "default", "default": true, "size": "NKR-20", "replicas_per_cell": float64(1)},
+		},
+	})
+}
+
+func TestBackup_RestoreShowCmd_RejectsNonNeki(t *testing.T) {
+	c := qt.New(t)
+
+	backupSvc := &mock.BackupsService{}
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Kind: ps.DatabaseEnginePostgres}, nil
+		},
+	}
+	format := printer.JSON
+	ch := &cmdutil.Helper{
+		Printer: printer.NewPrinter(&format),
+		Config:  &config.Config{Organization: "planetscale"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{Databases: dbSvc, Backups: backupSvc}, nil
+		},
+	}
+
+	cmd := RestoreCmd(ch)
+	cmd.SetArgs([]string{"show", "app", "main", "bak_123"})
+	c.Assert(cmd.Execute(), qt.ErrorMatches, `.*only supported for Neki databases`)
+	c.Assert(backupSvc.GetFnInvoked, qt.IsFalse)
+}
+
+func TestBackup_RestoreShowCmd_Human(t *testing.T) {
+	c := qt.New(t)
+
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "planetscale"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{
+				Databases: &mock.DatabaseService{
+					GetFn: func(context.Context, *ps.GetDatabaseRequest) (*ps.Database, error) {
+						return &ps.Database{Kind: ps.DatabaseEngineNeki}, nil
+					},
+				},
+				Backups: &mock.BackupsService{
+					GetFn: func(context.Context, *ps.GetBackupRequest) (*ps.Backup, error) {
+						return &ps.Backup{Name: "bak_123"}, nil
+					},
+				},
+				NekiShardConfigurationProfiles: &mock.NekiShardConfigurationProfilesService{
+					ListFn: func(context.Context, *ps.ListNekiShardConfigurationProfilesRequest) ([]*ps.NekiShardConfigurationProfile, error) {
+						return []*ps.NekiShardConfigurationProfile{
+							{Name: "default", Default: true, ClusterSize: "PS_40", Replicas: 2},
+						}, nil
+					},
+				},
+				NekiRouters: &mock.NekiRoutersService{
+					ListFn: func(context.Context, *ps.ListNekiRoutersRequest) ([]*ps.NekiRouter, error) {
+						return []*ps.NekiRouter{
+							{Name: "default", Default: true, SKU: &ps.NekiRouterSKU{Name: "NKR_20"}, ReplicasPerCell: 1},
+						}, nil
+					},
+				},
+			}, nil
+		},
+	}
+
+	cmd := RestoreCmd(ch)
+	cmd.SetArgs([]string{"show", "app", "main", "bak_123"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "live source sizes")
+	c.Assert(out.String(), qt.Contains, "CLUSTER SIZE")
+	c.Assert(out.String(), qt.Contains, "PS_40")
+	c.Assert(out.String(), qt.Contains, "REPLICAS PER CELL")
+	c.Assert(out.String(), qt.Contains, "NKR_20")
+}
diff --git a/internal/cmd/backup/restore_test.go b/internal/cmd/backup/restore_test.go
index 6b1506ed0..02746f34f 100644
--- a/internal/cmd/backup/restore_test.go
+++ b/internal/cmd/backup/restore_test.go
@@ -158,3 +158,146 @@ func TestBackup_RestoreCmdRejectsReplicasForMySQL(t *testing.T) {
 	c.Assert(cmd.Execute(), qt.ErrorMatches, ".*--replicas is only supported for PostgreSQL.*")
 	c.Assert(svc.CreateFnInvoked, qt.IsFalse)
 }
+
+func TestBackup_RestoreCmd_Neki(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(&buf)
+
+	org := "planetscale"
+	db := "planetscale"
+	branch := "restore-branch"
+	backup := "mybackup"
+
+	res := &ps.PostgresBranch{Name: "restore-branch"}
+	replicas := 2
+	replicasPerCell := 1
+
+	svc := &mock.PostgresBranchesService{
+		CreateFn: func(ctx context.Context, req *ps.CreatePostgresBranchRequest) (*ps.PostgresBranch, error) {
+			c.Assert(req.Organization, qt.Equals, org)
+			c.Assert(req.Database, qt.Equals, db)
+			c.Assert(req.Name, qt.Equals, branch)
+			c.Assert(req.BackupID, qt.Equals, backup)
+			c.Assert(req.ClusterName, qt.Equals, "")
+			c.Assert(req.ConfigurationProfileSizes, qt.DeepEquals, []ps.ConfigurationProfileSize{
+				{Name: "default", ClusterSize: "PS_40", Replicas: &replicas},
+			})
+			c.Assert(req.RouterSizes, qt.DeepEquals, []ps.RouterSize{
+				{Name: "default", RouterSize: "NKR_20", ReplicasPerCell: &replicasPerCell},
+			})
+			return res, nil
+		},
+	}
+
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Kind: ps.DatabaseEngineNeki}, nil
+		},
+	}
+
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config: &config.Config{
+			Organization: org,
+		},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{
+				PostgresBranches: svc,
+				Databases:        dbSvc,
+			}, nil
+		},
+	}
+
+	cmd := RestoreCmd(ch)
+	cmd.SetArgs([]string{
+		db, branch, backup,
+		"--config-profile", "name=default,cluster-size=PS-40,replicas=2",
+		"--router", "name=default,size=NKR-20,replicas-per-cell=1",
+	})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(svc.CreateFnInvoked, qt.IsTrue)
+	c.Assert(buf.String(), qt.JSONEquals, res)
+}
+
+func TestBackup_RestoreCmd_NekiClusterSize(t *testing.T) {
+	c := qt.New(t)
+
+	svc := &mock.PostgresBranchesService{
+		CreateFn: func(ctx context.Context, req *ps.CreatePostgresBranchRequest) (*ps.PostgresBranch, error) {
+			c.Assert(req.ClusterName, qt.Equals, "PS_40")
+			return &ps.PostgresBranch{Name: "restore-branch"}, nil
+		},
+	}
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Kind: ps.DatabaseEngineNeki}, nil
+		},
+	}
+	format := printer.JSON
+	ch := &cmdutil.Helper{
+		Printer: printer.NewPrinter(&format),
+		Config:  &config.Config{Organization: "planetscale"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{PostgresBranches: svc, Databases: dbSvc}, nil
+		},
+	}
+
+	cmd := RestoreCmd(ch)
+	cmd.SetArgs([]string{"planetscale", "restore-branch", "mybackup", "--cluster-size", "PS_40"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.CreateFnInvoked, qt.IsTrue)
+}
+
+func TestBackup_RestoreCmd_RejectsNekiSizingOnPostgres(t *testing.T) {
+	c := qt.New(t)
+
+	svc := &mock.PostgresBranchesService{}
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Kind: ps.DatabaseEnginePostgres}, nil
+		},
+	}
+	format := printer.JSON
+	ch := &cmdutil.Helper{
+		Printer: printer.NewPrinter(&format),
+		Config:  &config.Config{Organization: "planetscale"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{PostgresBranches: svc, Databases: dbSvc}, nil
+		},
+	}
+
+	cmd := RestoreCmd(ch)
+	cmd.SetArgs([]string{"planetscale", "restore-branch", "mybackup", "--config-profile", "name=default,replicas=2"})
+	c.Assert(cmd.Execute(), qt.ErrorMatches, `.*only supported for Neki backup restores`)
+	c.Assert(svc.CreateFnInvoked, qt.IsFalse)
+}
+
+func TestBackup_RestoreCmd_RejectsNekiSizingOnMySQL(t *testing.T) {
+	c := qt.New(t)
+
+	svc := &mock.DatabaseBranchesService{}
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Kind: "mysql"}, nil
+		},
+	}
+	format := printer.JSON
+	ch := &cmdutil.Helper{
+		Printer: printer.NewPrinter(&format),
+		Config:  &config.Config{Organization: "planetscale"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{DatabaseBranches: svc, Databases: dbSvc}, nil
+		},
+	}
+
+	cmd := RestoreCmd(ch)
+	cmd.SetArgs([]string{"planetscale", "restore-branch", "mybackup", "--router", "name=default,size=NKR_20"})
+	c.Assert(cmd.Execute(), qt.ErrorMatches, `.*only supported for Neki backup restores`)
+	c.Assert(svc.CreateFnInvoked, qt.IsFalse)
+}
diff --git a/internal/cmd/branch/branch.go b/internal/cmd/branch/branch.go
index 39ece281f..98e93cb5f 100644
--- a/internal/cmd/branch/branch.go
+++ b/internal/cmd/branch/branch.go
@@ -4,12 +4,27 @@ import (
 	"encoding/json"
 	"time"
 
+	"github.com/planetscale/cli/internal/cmd/admin"
 	"github.com/planetscale/cli/internal/cmd/branch/vtctld"
+	"github.com/planetscale/cli/internal/cmd/configprofile"
+	"github.com/planetscale/cli/internal/cmd/router"
+	"github.com/planetscale/cli/internal/cmd/shard"
+	"github.com/planetscale/cli/internal/cmd/sidecar"
 	"github.com/planetscale/cli/internal/cmdutil"
 	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
 	"github.com/spf13/cobra"
 )
 
+const (
+	branchGroupDatabase      = "database"
+	branchGroupMySQLPostgres = "mysql-postgres"
+	branchGroupVitess        = "vitess"
+	branchGroupPostgres      = "postgres"
+	branchGroupPostgresNeki  = "postgres-neki"
+	branchGroupNeki          = "neki"
+)
+
 // BranchCmd handles the branching of a database.
 func BranchCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
@@ -22,31 +37,51 @@ func BranchCmd(ch *cmdutil.Helper) *cobra.Command {
 		"The organization for the current user")
 	cmd.MarkPersistentFlagRequired("org") // nolint:errcheck
 
-	cmd.AddCommand(CreateCmd(ch))
-	cmd.AddCommand(ListCmd(ch))
-	cmd.AddCommand(DeleteCmd(ch))
-	cmd.AddCommand(ResizeCmd(ch))
-	cmd.AddCommand(VtgateCmd(ch))
-	cmd.AddCommand(ParametersCmd(ch))
-	cmd.AddCommand(ExtensionsCmd(ch))
-	cmd.AddCommand(ShowCmd(ch))
-	cmd.AddCommand(UpdateCmd(ch))
-	cmd.AddCommand(SwitchCmd(ch))
-	cmd.AddCommand(DiffCmd(ch))
-	cmd.AddCommand(SchemaCmd(ch))
-	cmd.AddCommand(RefreshSchemaCmd(ch))
-	cmd.AddCommand(PromoteCmd(ch))
-	cmd.AddCommand(DemoteCmd(ch))
-	cmd.AddCommand(RoutingRulesCmd(ch))
-	cmd.AddCommand(SafeMigrationsCmd(ch))
-	cmd.AddCommand(LintCmd(ch))
-	cmd.AddCommand(ConnectionsCmd(ch))
-	cmd.AddCommand(ProcesslistCmd(ch))
-	cmd.AddCommand(QueryPatternsCmd(ch))
-	cmd.AddCommand(vtctld.VtctldCmd(ch))
-	cmd.AddCommand(InfraCmd(ch))
-	cmd.AddCommand(SwitchoverCmd(ch))
-	cmd.AddCommand(MaintenanceCmd(ch))
+	cmd.AddGroup(
+		&cobra.Group{ID: branchGroupDatabase, Title: printer.Bold("MySQL, Postgres, and Neki branch commands:")},
+		&cobra.Group{ID: branchGroupMySQLPostgres, Title: printer.Bold("MySQL and Postgres:")},
+		&cobra.Group{ID: branchGroupVitess, Title: printer.Bold("Vitess/MySQL-specific:")},
+		&cobra.Group{ID: branchGroupPostgres, Title: printer.Bold("Postgres-specific:")},
+		&cobra.Group{ID: branchGroupPostgresNeki, Title: printer.Bold("Postgres and Neki:")},
+		&cobra.Group{ID: branchGroupNeki, Title: printer.Bold("Neki-specific:")},
+	)
+
+	add := func(group string, command *cobra.Command) {
+		command.GroupID = group
+		cmd.AddCommand(command)
+	}
+
+	add(branchGroupDatabase, CreateCmd(ch))
+	add(branchGroupDatabase, ListCmd(ch))
+	add(branchGroupDatabase, DeleteCmd(ch))
+	add(branchGroupDatabase, ShowCmd(ch))
+	add(branchGroupDatabase, UpdateCmd(ch))
+	add(branchGroupDatabase, SwitchCmd(ch))
+	add(branchGroupDatabase, SchemaCmd(ch))
+	add(branchGroupDatabase, PromoteCmd(ch))
+	add(branchGroupDatabase, DemoteCmd(ch))
+	add(branchGroupMySQLPostgres, ConnectionsCmd(ch))
+	add(branchGroupDatabase, InfraCmd(ch))
+	add(branchGroupVitess, DiffCmd(ch))
+	add(branchGroupVitess, LintCmd(ch))
+	add(branchGroupVitess, RefreshSchemaCmd(ch))
+	add(branchGroupVitess, RoutingRulesCmd(ch))
+	add(branchGroupVitess, SafeMigrationsCmd(ch))
+	add(branchGroupVitess, QueryPatternsCmd(ch))
+	add(branchGroupVitess, ProcesslistCmd(ch))
+	add(branchGroupVitess, VtgateCmd(ch))
+	add(branchGroupVitess, vtctld.VtctldCmd(ch))
+	add(branchGroupPostgres, ResizeCmd(ch))
+	add(branchGroupPostgres, ParametersCmd(ch))
+	add(branchGroupPostgres, ExtensionsCmd(ch))
+	add(branchGroupPostgres, SwitchoverCmd(ch))
+	add(branchGroupPostgresNeki, MaintenanceCmd(ch))
+	add(branchGroupNeki, DataTopologyCmd(ch))
+	add(branchGroupNeki, admin.AdminCmd(ch))
+	add(branchGroupNeki, configprofile.ConfigProfileCmd(ch))
+	add(branchGroupNeki, router.RouterCmd(ch))
+	add(branchGroupNeki, shard.ShardCmd(ch))
+	add(branchGroupNeki, sidecar.SidecarCmd(ch))
 
 	return cmd
 }
diff --git a/internal/cmd/branch/branch_test.go b/internal/cmd/branch/branch_test.go
new file mode 100644
index 000000000..023ba987a
--- /dev/null
+++ b/internal/cmd/branch/branch_test.go
@@ -0,0 +1,45 @@
+package branch
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/config"
+)
+
+func TestBranchCmdGroupsCommandsByEngine(t *testing.T) {
+	c := qt.New(t)
+
+	cmd := BranchCmd(&cmdutil.Helper{Config: &config.Config{}})
+
+	groups := map[string]string{}
+	for _, group := range cmd.Groups() {
+		groups[group.ID] = group.Title
+	}
+	c.Assert(groups[branchGroupDatabase], qt.Contains, "MySQL, Postgres, and Neki branch commands:")
+	c.Assert(groups[branchGroupMySQLPostgres], qt.Contains, "MySQL and Postgres:")
+	c.Assert(groups[branchGroupVitess], qt.Contains, "Vitess/MySQL-specific:")
+	c.Assert(groups[branchGroupPostgres], qt.Contains, "Postgres-specific:")
+	c.Assert(groups[branchGroupPostgresNeki], qt.Contains, "Postgres and Neki:")
+	c.Assert(groups[branchGroupNeki], qt.Contains, "Neki-specific:")
+
+	got := map[string]string{}
+	for _, command := range cmd.Commands() {
+		got[command.Name()] = command.GroupID
+	}
+
+	c.Assert(got["create"], qt.Equals, branchGroupDatabase)
+	c.Assert(got["connections"], qt.Equals, branchGroupMySQLPostgres)
+	c.Assert(got["lint"], qt.Equals, branchGroupVitess)
+	c.Assert(got["routing-rules"], qt.Equals, branchGroupVitess)
+	c.Assert(got["resize"], qt.Equals, branchGroupPostgres)
+	c.Assert(got["parameters"], qt.Equals, branchGroupPostgres)
+	c.Assert(got["maintenance"], qt.Equals, branchGroupPostgresNeki)
+	c.Assert(got["data-topology"], qt.Equals, branchGroupNeki)
+	c.Assert(got["admin"], qt.Equals, branchGroupNeki)
+	c.Assert(got["config-profile"], qt.Equals, branchGroupNeki)
+	c.Assert(got["router"], qt.Equals, branchGroupNeki)
+	c.Assert(got["shard"], qt.Equals, branchGroupNeki)
+	c.Assert(got["sidecar"], qt.Equals, branchGroupNeki)
+}
diff --git a/internal/cmd/branch/connections.go b/internal/cmd/branch/connections.go
index 70bef7e1f..39f688f41 100644
--- a/internal/cmd/branch/connections.go
+++ b/internal/cmd/branch/connections.go
@@ -10,8 +10,15 @@ import (
 func ConnectionsCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "connections <command>",
-		Short: "Show and kill branch connections",
-		Long: `Show and kill branch connections.
+		Short: "Show and kill MySQL or Postgres branch connections",
+		Long: `Show and kill MySQL or Postgres branch connections. Neki is not supported.
+
+MySQL (Vitess):
+  show/kill/top with --keyspace and --shard.
+
+Postgres:
+  show/top with --instance or --role.
+  kill-transaction terminates a transaction_id from show.
 
 Agent workflow:
   1. Run: pscale branch connections show <database> <branch> --format json
diff --git a/internal/cmd/branch/connections/engine_flags.go b/internal/cmd/branch/connections/engine_flags.go
index 43d0dffb2..a9c7ac898 100644
--- a/internal/cmd/branch/connections/engine_flags.go
+++ b/internal/cmd/branch/connections/engine_flags.go
@@ -6,12 +6,17 @@ import (
 	ps "github.com/planetscale/cli/internal/planetscale"
 )
 
+var errNekiUnsupported = errors.New("connections is not supported for Neki databases")
+
 // ValidateEngineFlags rejects flags that only apply to another database engine.
 func ValidateEngineFlags(engine ps.DatabaseEngine, filter ConnectionFilter, target ConnectionTarget) error {
 	return validateEngineFlags(engine, filter.connectionFilter(), target)
 }
 
 func validateEngineFlags(engine ps.DatabaseEngine, filter connectionFilter, target ConnectionTarget) error {
+	if engine == ps.DatabaseEngineNeki {
+		return errNekiUnsupported
+	}
 	switch engine {
 	case ps.DatabaseEnginePostgres:
 		if target.Keyspace != "" || target.Shard != "" {
diff --git a/internal/cmd/branch/connections/engine_flags_test.go b/internal/cmd/branch/connections/engine_flags_test.go
new file mode 100644
index 000000000..9fb1f2015
--- /dev/null
+++ b/internal/cmd/branch/connections/engine_flags_test.go
@@ -0,0 +1,16 @@
+package connections
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+	ps "github.com/planetscale/cli/internal/planetscale"
+)
+
+func TestValidateEngineFlagsRejectsNeki(t *testing.T) {
+	c := qt.New(t)
+
+	err := ValidateEngineFlags(ps.DatabaseEngineNeki, ConnectionFilter{}, ConnectionTarget{})
+
+	c.Assert(err, qt.ErrorMatches, "connections is not supported for Neki databases")
+}
diff --git a/internal/cmd/branch/connections/top.go b/internal/cmd/branch/connections/top.go
index 701b34f7c..c1349788e 100644
--- a/internal/cmd/branch/connections/top.go
+++ b/internal/cmd/branch/connections/top.go
@@ -36,7 +36,7 @@ previously captured trace in the TUI — actions are rejected in replay mode.
 
 For Postgres, connections top shows session activity across instances. For
 Vitess, pass --keyspace and --shard or run interactively to select them when
-the server reports available targets.`,
+the server reports available targets. Neki is not supported.`,
 		Args: func(cmd *cobra.Command, args []string) error {
 			if flags.replay != "" {
 				return nil
diff --git a/internal/cmd/branch/connections/top_test.go b/internal/cmd/branch/connections/top_test.go
index 03547b091..120bedd38 100644
--- a/internal/cmd/branch/connections/top_test.go
+++ b/internal/cmd/branch/connections/top_test.go
@@ -162,6 +162,12 @@ func TestTopCmdValidation(t *testing.T) {
 			args:    []string{"shop", "main", "--role", "primary"},
 			wantErr: "--instance/--role are only supported for Postgres databases",
 		},
+		{
+			name:    "neki is not supported",
+			engine:  ps.DatabaseEngineNeki,
+			args:    []string{"neki", "main"},
+			wantErr: "connections is not supported for Neki databases",
+		},
 		{
 			name:    "unknown role",
 			engine:  ps.DatabaseEnginePostgres,
diff --git a/internal/cmd/branch/connections_commands.go b/internal/cmd/branch/connections_commands.go
index 3284e6302..8a5e5e1ad 100644
--- a/internal/cmd/branch/connections_commands.go
+++ b/internal/cmd/branch/connections_commands.go
@@ -119,6 +119,9 @@ the matching Postgres connection.`,
 			if err != nil {
 				return err
 			}
+			if err := connections.ValidateEngineFlags(engine, connections.ConnectionFilter{}, connections.ConnectionTarget{}); err != nil {
+				return err
+			}
 			if engine != ps.DatabaseEnginePostgres {
 				return errors.New("connections kill-transaction is only supported for Postgres databases")
 			}
diff --git a/internal/cmd/branch/connections_test.go b/internal/cmd/branch/connections_test.go
index 3a2974559..d3556a9ea 100644
--- a/internal/cmd/branch/connections_test.go
+++ b/internal/cmd/branch/connections_test.go
@@ -36,6 +36,15 @@ func TestConnectionsCmdConstruction(t *testing.T) {
 	}
 }
 
+func TestConnectionsHelpListsEngines(t *testing.T) {
+	c := qt.New(t)
+
+	help := connectionsHelpForTest(c, "--help")
+	c.Assert(help, qt.Contains, "MySQL (Vitess):")
+	c.Assert(help, qt.Contains, "Postgres:")
+	c.Assert(help, qt.Contains, "Neki is not supported")
+}
+
 func TestConnectionsShowHelpListsTargetAndFilterFlags(t *testing.T) {
 	c := qt.New(t)
 
@@ -252,6 +261,12 @@ func TestConnectionsShowRejectsEngineSpecificFlags(t *testing.T) {
 			args:    []string{"show", "pgload", "main", "--keyspace", "commerce", "--shard", "-80"},
 			wantErr: "--keyspace/--shard are only supported for Vitess databases",
 		},
+		{
+			name:    "neki is not supported",
+			engine:  ps.DatabaseEngineNeki,
+			args:    []string{"show", "neki", "main"},
+			wantErr: "connections is not supported for Neki databases",
+		},
 	}
 
 	for _, tt := range tests {
@@ -522,6 +537,32 @@ func TestConnectionsKillTransactionRejectsVitess(t *testing.T) {
 	c.Assert(err, qt.ErrorMatches, "connections kill-transaction is only supported for Postgres databases")
 }
 
+func TestConnectionsRejectsNekiBeforeAPI(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+	}{
+		{name: "show", args: []string{"show", "neki", "main"}},
+		{name: "kill", args: []string{"kill", "neki", "main", "primary-123-c"}},
+		{name: "kill-transaction", args: []string{"kill-transaction", "neki", "main", "primary-123-t"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := qt.New(t)
+			server := liveConnectionsBranchServer(t, func(w http.ResponseWriter, r *http.Request) {
+				c.Fatalf("%s should reject Neki before calling %s", tt.name, r.URL.Path)
+			})
+			cmd := connectionsCmdForTest(connectionsTestHelper("acme", ps.DatabaseEngineNeki, nil, server.URL, printer.JSON, &bytes.Buffer{}))
+			cmd.SetArgs(tt.args)
+
+			err := cmd.Execute()
+
+			c.Assert(err, qt.ErrorMatches, "connections is not supported for Neki databases")
+		})
+	}
+}
+
 func TestPostgresActionResultOmitsVitessTopologyColumns(t *testing.T) {
 	c := qt.New(t)
 
diff --git a/internal/cmd/branch/create.go b/internal/cmd/branch/create.go
index 16231121a..b55fdbe50 100644
--- a/internal/cmd/branch/create.go
+++ b/internal/cmd/branch/create.go
@@ -14,17 +14,19 @@ import (
 
 func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
 	var flags struct {
-		wait          bool
-		dataBranching bool
-		region        string
-		parentBranch  string
-		clusterSize   string
-		backupID      string
-		restorePoint  string
-		majorVersion  string
-		replicas      int
-		minStorage    int64
-		maxStorage    int64
+		wait           bool
+		dataBranching  bool
+		region         string
+		parentBranch   string
+		clusterSize    string
+		backupID       string
+		restorePoint   string
+		majorVersion   string
+		replicas       int
+		minStorage     int64
+		maxStorage     int64
+		configProfiles []string
+		routers        []string
 	}
 
 	cmd := &cobra.Command{
@@ -113,7 +115,7 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
 			}
 
 			clusterSize := flags.clusterSize
-			if clusterSize == "" {
+			if clusterSize == "" && db.Kind != ps.DatabaseEngineNeki {
 				if flags.backupID != "" || flags.restorePoint != "" || flags.dataBranching {
 					clusterSize = "PS-10"
 				} else {
@@ -121,6 +123,10 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
 				}
 			}
 
+			if err := cmdutil.EnsureNekiRestoreSizing(db.Kind, flags.backupID != "", flags.dataBranching, len(flags.configProfiles) > 0 || len(flags.routers) > 0); err != nil {
+				return err
+			}
+
 			if db.Kind == "mysql" {
 				if cmd.Flags().Changed("replicas") {
 					return fmt.Errorf("--replicas is only supported for PostgreSQL backup restores and point-in-time recovery")
@@ -221,6 +227,10 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
 					createReq.Replicas = &replicas
 				}
 
+				if err := cmdutil.ApplyNekiRestoreSizing(createReq, flags.configProfiles, flags.routers); err != nil {
+					return err
+				}
+
 				if cmd.Flags().Changed("min-storage") || cmd.Flags().Changed("max-storage") {
 					createReq.Storage = &ps.StorageConfig{}
 					if cmd.Flags().Changed("min-storage") {
@@ -282,13 +292,15 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd.Flags().StringVar(&flags.region, "region", "", "Region for the branch to be created in.")
 	cmd.Flags().StringVar(&flags.backupID, "restore", "", "ID of Backup to restore into branch.")
 	cmd.Flags().StringVar(&flags.restorePoint, "restore-point", "", "For PostgreSQL databases, restore from a point-in-time recovery timestamp (e.g. 2023-01-01T00:00:00Z). Requires --restore or --from.")
-	cmd.Flags().StringVar(&flags.clusterSize, "cluster-size", "", "Cluster size for the branch. Defaults to PS_DEV for regular branches, or PS-10 for branches created from a backup or with seed-data. Use 'pscale size cluster list' to see the valid sizes.")
+	cmd.Flags().StringVar(&flags.clusterSize, "cluster-size", "", "Cluster size for the branch. Defaults to PS_DEV for regular branches, or PS-10 for branches created from a backup or with seed-data. Omitted for Neki so the API uses the database default. Use 'pscale size cluster list' to see the valid sizes.")
 	cmd.Flags().BoolVar(&flags.dataBranching, "seed-data", false, "Add seed data using the Data Branching™ feature. This branch will be created with the same resources as the base branch.")
 	cmd.Flags().BoolVar(&flags.wait, "wait", false, "Wait until the branch is ready")
 	cmd.Flags().StringVar(&flags.majorVersion, "major-version", "", "For PostgreSQL databases, the PostgreSQL major version to use for the branch. Defaults to the major version of the parent branch if it exists or the database's default branch major version. Ignored for branches restored from backups.")
 	cmd.Flags().IntVar(&flags.replicas, "replicas", 0, "Number of additional replicas for a PostgreSQL restore. 0 creates a single-node branch; omit to use the target cluster size default.")
 	cmd.Flags().Int64Var(&flags.minStorage, "min-storage", 0, "Minimum storage size in bytes")
 	cmd.Flags().Int64Var(&flags.maxStorage, "max-storage", 0, "Maximum storage size in bytes for autoscaling")
+	cmd.Flags().StringArrayVar(&flags.configProfiles, "config-profile", nil, cmdutil.ConfigProfileSizeFlagHelp)
+	cmd.Flags().StringArrayVar(&flags.routers, "router", nil, cmdutil.RouterSizeFlagHelp)
 
 	cmd.MarkFlagsMutuallyExclusive("restore", "seed-data")
 	cmd.MarkFlagsMutuallyExclusive("restore-point", "seed-data")
diff --git a/internal/cmd/branch/create_test.go b/internal/cmd/branch/create_test.go
index 2188cfae1..a277f090f 100644
--- a/internal/cmd/branch/create_test.go
+++ b/internal/cmd/branch/create_test.go
@@ -412,6 +412,171 @@ func TestBranch_CreateCmdWithMajorVersion(t *testing.T) {
 	c.Assert(buf.String(), qt.JSONEquals, res)
 }
 
+func TestBranch_CreateCmdNekiOmitsDefaultClusterSize(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(&buf)
+
+	org := "planetscale"
+	db := "planetscale"
+	branch := "development"
+
+	res := &ps.PostgresBranch{Name: branch}
+
+	svc := &mock.PostgresBranchesService{
+		CreateFn: func(ctx context.Context, req *ps.CreatePostgresBranchRequest) (*ps.PostgresBranch, error) {
+			c.Assert(req.Name, qt.Equals, branch)
+			c.Assert(req.Database, qt.Equals, db)
+			c.Assert(req.Organization, qt.Equals, org)
+			c.Assert(req.ParentBranch, qt.Equals, "main")
+			c.Assert(req.ClusterName, qt.Equals, "")
+
+			return res, nil
+		},
+	}
+
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			c.Assert(req.Database, qt.Equals, db)
+			c.Assert(req.Organization, qt.Equals, org)
+			return &ps.Database{Kind: ps.DatabaseEngineNeki}, nil
+		},
+	}
+
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config: &config.Config{
+			Organization: org,
+		},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{
+				PostgresBranches: svc,
+				Databases:        dbSvc,
+			}, nil
+		},
+	}
+
+	cmd := CreateCmd(ch)
+	cmd.SetArgs([]string{db, branch, "--from", "main"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(svc.CreateFnInvoked, qt.IsTrue)
+	c.Assert(buf.String(), qt.JSONEquals, res)
+}
+
+func TestBranch_CreateCmdNekiRespectsClusterSize(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(&buf)
+
+	org := "planetscale"
+	db := "planetscale"
+	branch := "development"
+
+	res := &ps.PostgresBranch{Name: branch}
+
+	svc := &mock.PostgresBranchesService{
+		CreateFn: func(ctx context.Context, req *ps.CreatePostgresBranchRequest) (*ps.PostgresBranch, error) {
+			c.Assert(req.ClusterName, qt.Equals, "PS_10_AWS_ARM_NEKI")
+
+			return res, nil
+		},
+	}
+
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Kind: ps.DatabaseEngineNeki}, nil
+		},
+	}
+
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config: &config.Config{
+			Organization: org,
+		},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{
+				PostgresBranches: svc,
+				Databases:        dbSvc,
+			}, nil
+		},
+	}
+
+	cmd := CreateCmd(ch)
+	cmd.SetArgs([]string{db, branch, "--from", "main", "--cluster-size", "PS_10_AWS_ARM_NEKI"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(svc.CreateFnInvoked, qt.IsTrue)
+	c.Assert(buf.String(), qt.JSONEquals, res)
+}
+
+func TestBranch_CreateCmdNekiWithWaitPrintsReadyBranch(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(&buf)
+
+	org := "planetscale"
+	db := "planetscale"
+	branch := "development"
+
+	pending := &ps.PostgresBranch{Name: branch, Kind: "neki", Ready: false}
+	ready := &ps.PostgresBranch{Name: branch, Kind: "neki", Ready: true}
+
+	branchSvc := &mock.PostgresBranchesService{
+		CreateFn: func(_ context.Context, req *ps.CreatePostgresBranchRequest) (*ps.PostgresBranch, error) {
+			c.Assert(req.Organization, qt.Equals, org)
+			c.Assert(req.Database, qt.Equals, db)
+			c.Assert(req.Name, qt.Equals, branch)
+			return pending, nil
+		},
+		GetFn: func(_ context.Context, req *ps.GetPostgresBranchRequest) (*ps.PostgresBranch, error) {
+			c.Assert(req, qt.DeepEquals, &ps.GetPostgresBranchRequest{
+				Organization: org,
+				Database:     db,
+				Branch:       branch,
+			})
+			return ready, nil
+		},
+	}
+
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(_ context.Context, _ *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Kind: ps.DatabaseEngineNeki}, nil
+		},
+	}
+
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: org},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{
+				Databases:        dbSvc,
+				PostgresBranches: branchSvc,
+			}, nil
+		},
+	}
+	debug := false
+	ch.SetDebug(&debug)
+
+	cmd := CreateCmd(ch)
+	cmd.SetArgs([]string{db, branch, "--wait"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(branchSvc.GetFnInvoked, qt.IsTrue)
+	c.Assert(buf.String(), qt.JSONEquals, ready)
+}
+
 func TestBranch_CreateCmdWithStorageMySQLError(t *testing.T) {
 	c := qt.New(t)
 
@@ -1142,3 +1307,103 @@ func TestBranch_CreateCmdPropagatesReplicaValidationError(t *testing.T) {
 
 	c.Assert(cmd.Execute(), qt.Equals, validationErr)
 }
+
+func TestBranch_CreateCmdNekiRestoreWithSizes(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(&buf)
+
+	org := "planetscale"
+	db := "planetscale"
+	branch := "restored"
+	replicas := 2
+	replicasPerCell := 1
+	res := &ps.PostgresBranch{Name: branch}
+
+	svc := &mock.PostgresBranchesService{
+		CreateFn: func(ctx context.Context, req *ps.CreatePostgresBranchRequest) (*ps.PostgresBranch, error) {
+			c.Assert(req.BackupID, qt.Equals, "somebackupid")
+			c.Assert(req.ClusterName, qt.Equals, "")
+			c.Assert(req.ConfigurationProfileSizes, qt.DeepEquals, []ps.ConfigurationProfileSize{
+				{Name: "default", ClusterSize: "PS_40", Replicas: &replicas},
+			})
+			c.Assert(req.RouterSizes, qt.DeepEquals, []ps.RouterSize{
+				{Name: "default", RouterSize: "NKR_20", ReplicasPerCell: &replicasPerCell},
+			})
+			return res, nil
+		},
+	}
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Kind: ps.DatabaseEngineNeki}, nil
+		},
+	}
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: org},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{PostgresBranches: svc, Databases: dbSvc}, nil
+		},
+	}
+
+	cmd := CreateCmd(ch)
+	cmd.SetArgs([]string{
+		db, branch, "--restore", "somebackupid",
+		"--config-profile", "name=default,cluster-size=PS-40,replicas=2",
+		"--router", "name=default,size=NKR-20,replicas-per-cell=1",
+	})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.CreateFnInvoked, qt.IsTrue)
+	c.Assert(buf.String(), qt.JSONEquals, res)
+}
+
+func TestBranch_CreateCmdNekiSizingRequiresRestore(t *testing.T) {
+	c := qt.New(t)
+
+	svc := &mock.PostgresBranchesService{}
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Kind: ps.DatabaseEngineNeki}, nil
+		},
+	}
+	format := printer.JSON
+	ch := &cmdutil.Helper{
+		Printer: printer.NewPrinter(&format),
+		Config:  &config.Config{Organization: "planetscale"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{PostgresBranches: svc, Databases: dbSvc}, nil
+		},
+	}
+
+	cmd := CreateCmd(ch)
+	cmd.SetArgs([]string{"planetscale", "development", "--from", "main", "--config-profile", "name=default,replicas=2"})
+	c.Assert(cmd.Execute(), qt.ErrorMatches, `.*can only be used when restoring a backup`)
+	c.Assert(svc.CreateFnInvoked, qt.IsFalse)
+}
+
+func TestBranch_CreateCmdMySQLRestoreRejectsNekiSizing(t *testing.T) {
+	c := qt.New(t)
+
+	svc := &mock.DatabaseBranchesService{}
+	dbSvc := &mock.DatabaseService{
+		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Kind: "mysql"}, nil
+		},
+	}
+	format := printer.JSON
+	ch := &cmdutil.Helper{
+		Printer: printer.NewPrinter(&format),
+		Config:  &config.Config{Organization: "planetscale"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{DatabaseBranches: svc, Databases: dbSvc}, nil
+		},
+	}
+
+	cmd := CreateCmd(ch)
+	cmd.SetArgs([]string{"planetscale", "development", "--restore", "somebackupid", "--router", "name=default,size=NKR_20"})
+	c.Assert(cmd.Execute(), qt.ErrorMatches, `.*only supported for Neki backup restores`)
+	c.Assert(svc.CreateFnInvoked, qt.IsFalse)
+}
diff --git a/internal/cmd/branch/data_topology.go b/internal/cmd/branch/data_topology.go
new file mode 100644
index 000000000..054e0f7be
--- /dev/null
+++ b/internal/cmd/branch/data_topology.go
@@ -0,0 +1,208 @@
+package branch
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func DataTopologyCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "data-topology <command>",
+		Short: "Fetch or update the data topology of a Neki branch",
+	}
+
+	cmd.AddCommand(GetDataTopologyCmd(ch))
+	cmd.AddCommand(ListDataTopologyCmd(ch))
+	cmd.AddCommand(UpdateDataTopologyCmd(ch))
+
+	return cmd
+}
+
+func ListDataTopologyCmd(ch *cmdutil.Helper) *cobra.Command {
+	var shards bool
+
+	cmd := &cobra.Command{
+		Use:   "ls <database> <branch>",
+		Short: "Show the relationships in a Neki branch's data topology",
+		Example: `  pscale branch data-topology ls mydb main --org my-org --format json
+  pscale branch data-topology ls mydb main --org my-org --shards --format json`,
+		Args: cmdutil.ExactArgs("database", "branch"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+			database, branch := args[0], args[1]
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			dataTopology, err := client.DatabaseBranches.DataTopology(ctx, &planetscale.BranchDataTopologyRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return handleDataTopologyError(err, database, branch, ch.Config.Organization)
+			}
+
+			switch ch.Printer.Format() {
+			case printer.Human:
+				var tree *dataTopologyTreeOutput
+				if shards {
+					tree, err = buildDataTopologyShardsTree(ch.Config.Organization, database, branch, dataTopology)
+				} else {
+					tree, err = buildDataTopologyTree(ch.Config.Organization, database, branch, dataTopology)
+				}
+				if err != nil {
+					return err
+				}
+				ch.Printer.Print(renderDataTopologyTree(tree.Tree))
+				return nil
+			case printer.JSON:
+				if shards {
+					output, err := buildDataTopologyShardsOutput(ch.Config.Organization, database, branch, dataTopology)
+					if err != nil {
+						return err
+					}
+					return ch.Printer.PrintResource(output)
+				}
+				output, err := buildDataTopologyListOutput(ch.Config.Organization, database, branch, dataTopology)
+				if err != nil {
+					return err
+				}
+				return ch.Printer.PrintResource(output)
+			default:
+				return errors.New("data-topology ls supports human and json output")
+			}
+		},
+	}
+
+	cmd.Flags().BoolVar(&shards, "shards", false, "Group data by the physical shards that host it")
+
+	return cmd
+}
+
+func GetDataTopologyCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:   "get <database> <branch>",
+		Short: "Show the data topology of a Neki branch",
+		Args:  cmdutil.ExactArgs("database", "branch"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+			database, branch := args[0], args[1]
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			dataTopology, err := client.DatabaseBranches.DataTopology(ctx, &planetscale.BranchDataTopologyRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return handleDataTopologyError(err, database, branch, ch.Config.Organization)
+			}
+
+			return printDataTopology(ch, dataTopology)
+		},
+	}
+}
+
+func UpdateDataTopologyCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:     "update <database> <branch>",
+		Short:   "Update the data topology of a Neki branch from standard input",
+		Example: `  pscale branch data-topology update mydb main --org my-org --format json < data-topology.json`,
+		Args:    cmdutil.ExactArgs("database", "branch"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+			database, branch := args[0], args[1]
+
+			data, err := readDataTopology(cmd)
+			if err != nil {
+				return err
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			dataTopology, err := client.DatabaseBranches.UpdateDataTopology(ctx, &planetscale.UpdateBranchDataTopologyRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				DataTopology: data,
+			})
+			if err != nil {
+				return handleDataTopologyError(err, database, branch, ch.Config.Organization)
+			}
+
+			return printDataTopology(ch, dataTopology)
+		},
+	}
+}
+
+func readDataTopology(cmd *cobra.Command) (json.RawMessage, error) {
+	stdin := cmd.InOrStdin()
+	if stdin == os.Stdin {
+		stdinFile, err := os.Stdin.Stat()
+		if err != nil {
+			return nil, err
+		}
+		if (stdinFile.Mode() & os.ModeCharDevice) != 0 {
+			return nil, errors.New("no data topology provided; pipe a JSON object to standard input")
+		}
+	}
+
+	data, err := io.ReadAll(stdin)
+	if err != nil {
+		return nil, err
+	}
+	data = bytes.TrimSpace(data)
+	if len(data) == 0 {
+		return nil, errors.New("no data topology provided; pipe a JSON object to standard input")
+	}
+
+	var topology map[string]json.RawMessage
+	if err := json.Unmarshal(data, &topology); err != nil {
+		return nil, fmt.Errorf("invalid data topology JSON: %w", err)
+	}
+	if topology == nil {
+		return nil, errors.New("invalid data topology JSON: expected an object")
+	}
+
+	return json.RawMessage(data), nil
+}
+
+func handleDataTopologyError(err error, database, branch, organization string) error {
+	if cmdutil.ErrCode(err) == planetscale.ErrNotFound {
+		return fmt.Errorf("branch %s does not exist or is not a Neki branch in database %s (organization: %s)",
+			printer.BoldBlue(branch), printer.BoldBlue(database), printer.BoldBlue(organization))
+	}
+
+	return cmdutil.HandleError(err)
+}
+
+func printDataTopology(ch *cmdutil.Helper, dataTopology *planetscale.DataTopology) error {
+	if ch.Printer.Format() != printer.Human {
+		return ch.Printer.PrintResource(dataTopology)
+	}
+
+	if err := ch.Printer.PrettyPrintJSON(dataTopology.DataTopology); err != nil {
+		return fmt.Errorf("reading data topology: %w", err)
+	}
+
+	return nil
+}
diff --git a/internal/cmd/branch/data_topology_output.go b/internal/cmd/branch/data_topology_output.go
new file mode 100644
index 000000000..cea09147c
--- /dev/null
+++ b/internal/cmd/branch/data_topology_output.go
@@ -0,0 +1,36 @@
+package branch
+
+import (
+	"time"
+
+	"github.com/planetscale/cli/internal/planetscale"
+)
+
+type dataTopologyListOutput struct {
+	Organization            string                            `json:"organization"`
+	Database                string                            `json:"database"`
+	Branch                  string                            `json:"branch"`
+	SyncedAt                *time.Time                        `json:"synced_at"`
+	AuthoritativeShardGroup string                            `json:"authoritative_shard_group"`
+	Databases               map[string]dataTopologyDatabase   `json:"databases"`
+	ShardGroups             []dataTopologyShardGroup          `json:"shard_groups"`
+	ShardIndexes            map[string]dataTopologyShardIndex `json:"shard_indexes"`
+}
+
+func buildDataTopologyListOutput(organization, database, branch string, dataTopology *planetscale.DataTopology) (*dataTopologyListOutput, error) {
+	document, err := parseDataTopologyDocument(dataTopology)
+	if err != nil {
+		return nil, err
+	}
+
+	return &dataTopologyListOutput{
+		Organization:            organization,
+		Database:                database,
+		Branch:                  branch,
+		SyncedAt:                dataTopology.SyncedAt,
+		AuthoritativeShardGroup: document.AuthoritativeShardGroup,
+		Databases:               document.Databases,
+		ShardGroups:             document.ShardGroups,
+		ShardIndexes:            document.ShardIndexes,
+	}, nil
+}
diff --git a/internal/cmd/branch/data_topology_shards.go b/internal/cmd/branch/data_topology_shards.go
new file mode 100644
index 000000000..673a6fe79
--- /dev/null
+++ b/internal/cmd/branch/data_topology_shards.go
@@ -0,0 +1,79 @@
+package branch
+
+import (
+	"time"
+
+	"github.com/planetscale/cli/internal/planetscale"
+)
+
+type dataTopologyShardsOutput struct {
+	Organization            string                       `json:"organization"`
+	Database                string                       `json:"database"`
+	Branch                  string                       `json:"branch"`
+	SyncedAt                *time.Time                   `json:"synced_at"`
+	AuthoritativeShardGroup string                       `json:"authoritative_shard_group"`
+	Shards                  map[string]dataTopologyShard `json:"shards"`
+}
+
+type dataTopologyShard struct {
+	Placements []dataTopologyPlacement `json:"placements"`
+}
+
+type dataTopologyPlacement struct {
+	ShardGroup        string                       `json:"shard_group"`
+	ShardGroupName    string                       `json:"shard_group_name,omitempty"`
+	Authoritative     bool                         `json:"authoritative"`
+	KeyRange          dataTopologyKeyRangeOutput   `json:"key_range"`
+	DefaultShardIndex string                       `json:"default_shard_index,omitempty"`
+	Tables            []dataTopologyHostedRelation `json:"tables,omitempty"`
+	ReferenceTables   []dataTopologyHostedRelation `json:"reference_tables,omitempty"`
+	Sequences         []dataTopologyHostedRelation `json:"sequences,omitempty"`
+}
+
+type dataTopologyKeyRangeOutput struct {
+	Start *string `json:"start"`
+	End   *string `json:"end"`
+}
+
+func buildDataTopologyShardsOutput(organization, database, branch string, dataTopology *planetscale.DataTopology) (*dataTopologyShardsOutput, error) {
+	document, err := parseDataTopologyDocument(dataTopology)
+	if err != nil {
+		return nil, err
+	}
+
+	output := &dataTopologyShardsOutput{
+		Organization:            organization,
+		Database:                database,
+		Branch:                  branch,
+		SyncedAt:                dataTopology.SyncedAt,
+		AuthoritativeShardGroup: document.AuthoritativeShardGroup,
+		Shards:                  make(map[string]dataTopologyShard),
+	}
+	placements := shardPlacementsByUID(document)
+	hostedData := dataHostedByShardGroup(document)
+	for _, shardUID := range sortedKeys(placements) {
+		shard := dataTopologyShard{}
+		for _, placement := range placements[shardUID] {
+			data := hostedData[placement.Group.UID]
+			shard.Placements = append(shard.Placements, dataTopologyPlacement{
+				ShardGroup:        placement.Group.UID,
+				ShardGroupName:    placement.Group.Name,
+				Authoritative:     placement.Group.UID == document.AuthoritativeShardGroup,
+				KeyRange:          dataTopologyKeyRangeOutput{Start: optionalTopologyBound(placement.KeyRange.Start), End: optionalTopologyBound(placement.KeyRange.End)},
+				DefaultShardIndex: placement.Group.DefaultShardIndex,
+				Tables:            data.Tables,
+				ReferenceTables:   data.ReferenceTables,
+				Sequences:         data.Sequences,
+			})
+		}
+		output.Shards[shardUID] = shard
+	}
+	return output, nil
+}
+
+func optionalTopologyBound(value string) *string {
+	if value == "" {
+		return nil
+	}
+	return &value
+}
diff --git a/internal/cmd/branch/data_topology_test.go b/internal/cmd/branch/data_topology_test.go
new file mode 100644
index 000000000..7e9293990
--- /dev/null
+++ b/internal/cmd/branch/data_topology_test.go
@@ -0,0 +1,426 @@
+package branch
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+	"time"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/config"
+	"github.com/planetscale/cli/internal/mock"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+const dataTopologyDiagramFixture = `{
+  "authoritative_shard_group": "authoritative",
+  "shard_indexes": {
+    "xxhash_product_id": {"type": "xxhash", "columns": ["product_id"]},
+    "xxhash_tenant_id": {"type": "xxhash", "columns": ["tenant_id"]}
+  },
+  "shard_groups": [
+    {
+      "uid": "authoritative",
+      "key_ranges": [{"shard_uid": "shard-meta"}]
+    },
+    {
+      "uid": "tenant_data",
+      "default_shard_index": "xxhash_tenant_id",
+      "key_ranges": [
+        {"shard_uid": "shard-a", "start": "00", "end": "40"},
+        {"shard_uid": "shard-b", "start": "40", "end": "80"},
+        {"shard_uid": "shard-c", "start": "80", "end": "c0"},
+        {"shard_uid": "shard-d", "start": "c0"}
+      ]
+    },
+    {
+      "uid": "catalog",
+      "default_shard_index": "xxhash_product_id",
+      "key_ranges": [
+        {"shard_uid": "shard-a", "start": "00", "end": "40"},
+        {"shard_uid": "shard-b", "start": "40", "end": "80"},
+        {"shard_uid": "shard-c", "start": "80", "end": "c0"},
+        {"shard_uid": "shard-d", "start": "c0"}
+      ]
+    }
+  ],
+  "databases": {
+    "commerce": {
+      "schemas": {
+        "public": {
+          "tables": {
+            "tenants": {"shard_group_uid": "tenant_data"},
+            "orders": {"shard_group_uid": "tenant_data"},
+            "products": {"shard_group_uid": "catalog"},
+            "price_history": {"shard_group_uid": "catalog"},
+            "countries": {"shard_group_uid": "authoritative"}
+          }
+        }
+      }
+    }
+  }
+}`
+
+func dataTopologyTestHelper(org string, format printer.Format, buf *bytes.Buffer, svc ps.DatabaseBranchesService) *cmdutil.Helper {
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(buf)
+	p.SetHumanOutput(buf)
+
+	return &cmdutil.Helper{
+		Printer: p,
+		Config: &config.Config{
+			Organization: org,
+		},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{DatabaseBranches: svc}, nil
+		},
+	}
+}
+
+func TestBranch_DataTopologyGetCmd(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	topology := &ps.DataTopology{
+		ID:           "topology-id",
+		Type:         "NekiDataTopology",
+		DataTopology: json.RawMessage(`{"authoritative_shard_group":"default"}`),
+	}
+	svc := &mock.DatabaseBranchesService{
+		DataTopologyFn: func(ctx context.Context, req *ps.BranchDataTopologyRequest) (*ps.DataTopology, error) {
+			c.Assert(req.Organization, qt.Equals, "my-org")
+			c.Assert(req.Database, qt.Equals, "my-db")
+			c.Assert(req.Branch, qt.Equals, "main")
+			return topology, nil
+		},
+	}
+	ch := dataTopologyTestHelper("my-org", printer.JSON, &buf, svc)
+
+	cmd := GetDataTopologyCmd(ch)
+	cmd.SetArgs([]string{"my-db", "main"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(svc.DataTopologyFnInvoked, qt.IsTrue)
+	c.Assert(buf.String(), qt.JSONEquals, topology)
+}
+
+func TestBranch_DataTopologyGetCmd_Human(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	topology := &ps.DataTopology{
+		DataTopology: json.RawMessage(`{"authoritative_shard_group":"default"}`),
+	}
+	svc := &mock.DatabaseBranchesService{
+		DataTopologyFn: func(ctx context.Context, req *ps.BranchDataTopologyRequest) (*ps.DataTopology, error) {
+			return topology, nil
+		},
+	}
+	ch := dataTopologyTestHelper("my-org", printer.Human, &buf, svc)
+
+	cmd := GetDataTopologyCmd(ch)
+	cmd.SetArgs([]string{"my-db", "main"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(buf.String(), qt.JSONEquals, map[string]any{
+		"authoritative_shard_group": "default",
+	})
+}
+
+func TestBranch_DataTopologyListCmd_Human(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	topology := &ps.DataTopology{DataTopology: json.RawMessage(dataTopologyDiagramFixture)}
+	svc := &mock.DatabaseBranchesService{
+		DataTopologyFn: func(ctx context.Context, req *ps.BranchDataTopologyRequest) (*ps.DataTopology, error) {
+			c.Assert(req.Organization, qt.Equals, "my-org")
+			c.Assert(req.Database, qt.Equals, "my-db")
+			c.Assert(req.Branch, qt.Equals, "main")
+			return topology, nil
+		},
+	}
+	ch := dataTopologyTestHelper("my-org", printer.Human, &buf, svc)
+
+	cmd := ListDataTopologyCmd(ch)
+	cmd.SetArgs([]string{"my-db", "main"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(svc.DataTopologyFnInvoked, qt.IsTrue)
+	c.Assert(buf.String(), qt.Equals, `my-org/my-db/main
+├── databases
+│   └── commerce
+│       └── schemas
+│           └── public
+│               └── tables
+│                   ├── countries → authoritative
+│                   ├── orders → tenant_data
+│                   ├── price_history → catalog
+│                   ├── products → catalog
+│                   └── tenants → tenant_data
+├── shard groups
+│   ├── authoritative [authoritative]
+│   │   └── key ranges
+│   │       └── [-∞, +∞) → shard-meta
+│   ├── catalog → xxhash_product_id
+│   │   └── key ranges
+│   │       ├── [00, 40) → shard-a
+│   │       ├── [40, 80) → shard-b
+│   │       ├── [80, c0) → shard-c
+│   │       └── [c0, +∞) → shard-d
+│   └── tenant_data → xxhash_tenant_id
+│       └── key ranges
+│           ├── [00, 40) → shard-a
+│           ├── [40, 80) → shard-b
+│           ├── [80, c0) → shard-c
+│           └── [c0, +∞) → shard-d
+└── shard indexes
+    ├── xxhash_product_id: xxhash(product_id)
+    └── xxhash_tenant_id: xxhash(tenant_id)
+`)
+}
+
+func TestDataTopologyTablesTree_ShowsPlacementInTableLabel(t *testing.T) {
+	c := qt.New(t)
+
+	database := dataTopologyDatabase{
+		DefaultShardGroup: "tenant_data",
+		GlobalSecondaryIndexes: map[string]dataTopologyGlobalIndex{
+			"users_email_idx": {Schema: "public", Table: "users_email_lookup"},
+		},
+	}
+	schema := dataTopologySchema{
+		Tables: map[string]dataTopologyTable{
+			"users": {
+				PrimaryIndexes: []dataTopologyPrimaryIndex{
+					{ShardIndex: "xxhash_tenant_id", Columns: []string{"tenant_id"}},
+				},
+				SecondaryIndexes: []dataTopologySecondaryIndex{
+					{Name: "users_email_idx", Columns: []string{"email"}},
+				},
+			},
+		},
+	}
+
+	c.Assert(renderDataTopologyTree(tablesTree("public", schema, database, "authoritative")), qt.Equals, `tables
+└── users → tenant_data (database default)
+    ├── primary index → xxhash_tenant_id (tenant_id)
+    └── secondary index → users_email_idx (email) → public.users_email_lookup
+`)
+}
+
+func TestBranch_DataTopologyListCmd_Human_Shards(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	topology := &ps.DataTopology{DataTopology: json.RawMessage(dataTopologyDiagramFixture)}
+	svc := &mock.DatabaseBranchesService{
+		DataTopologyFn: func(ctx context.Context, req *ps.BranchDataTopologyRequest) (*ps.DataTopology, error) {
+			return topology, nil
+		},
+	}
+	ch := dataTopologyTestHelper("my-org", printer.Human, &buf, svc)
+
+	cmd := ListDataTopologyCmd(ch)
+	cmd.SetArgs([]string{"my-db", "main", "--shards"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(buf.String(), qt.Equals, `my-org/my-db/main
+├── shard-a
+│   ├── catalog [00, 40)
+│   │   ├── commerce.public.price_history
+│   │   └── commerce.public.products
+│   └── tenant_data [00, 40)
+│       ├── commerce.public.orders
+│       └── commerce.public.tenants
+├── shard-b
+│   ├── catalog [40, 80)
+│   │   ├── commerce.public.price_history
+│   │   └── commerce.public.products
+│   └── tenant_data [40, 80)
+│       ├── commerce.public.orders
+│       └── commerce.public.tenants
+├── shard-c
+│   ├── catalog [80, c0)
+│   │   ├── commerce.public.price_history
+│   │   └── commerce.public.products
+│   └── tenant_data [80, c0)
+│       ├── commerce.public.orders
+│       └── commerce.public.tenants
+├── shard-d
+│   ├── catalog [c0, +∞)
+│   │   ├── commerce.public.price_history
+│   │   └── commerce.public.products
+│   └── tenant_data [c0, +∞)
+│       ├── commerce.public.orders
+│       └── commerce.public.tenants
+└── shard-meta
+    └── authoritative [-∞, +∞) [authoritative]
+        └── commerce.public.countries
+`)
+}
+
+func TestBranch_DataTopologyListCmd_JSON(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	syncedAt := time.Date(2026, time.August, 3, 12, 0, 0, 0, time.UTC)
+	topology := &ps.DataTopology{
+		DataTopology: json.RawMessage(dataTopologyDiagramFixture),
+		SyncedAt:     &syncedAt,
+	}
+	svc := &mock.DatabaseBranchesService{
+		DataTopologyFn: func(ctx context.Context, req *ps.BranchDataTopologyRequest) (*ps.DataTopology, error) {
+			return topology, nil
+		},
+	}
+	ch := dataTopologyTestHelper("my-org", printer.JSON, &buf, svc)
+
+	cmd := ListDataTopologyCmd(ch)
+	cmd.SetArgs([]string{"my-db", "main"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	var output dataTopologyListOutput
+	c.Assert(json.Unmarshal(buf.Bytes(), &output), qt.IsNil)
+	c.Assert(output.Organization, qt.Equals, "my-org")
+	c.Assert(output.Database, qt.Equals, "my-db")
+	c.Assert(output.Branch, qt.Equals, "main")
+	c.Assert(output.SyncedAt, qt.DeepEquals, &syncedAt)
+	c.Assert(output.AuthoritativeShardGroup, qt.Equals, "authoritative")
+	c.Assert(output.Databases, qt.HasLen, 1)
+	c.Assert(output.Databases["commerce"].Schemas["public"].Tables, qt.HasLen, 5)
+	c.Assert(output.Databases["commerce"].Schemas["public"].Tables["countries"].ShardGroupUID, qt.Equals, "authoritative")
+	c.Assert(output.ShardGroups, qt.HasLen, 3)
+	c.Assert(output.ShardGroups[1].UID, qt.Equals, "tenant_data")
+	c.Assert(output.ShardGroups[1].DefaultShardIndex, qt.Equals, "xxhash_tenant_id")
+	c.Assert(output.ShardGroups[1].KeyRanges, qt.HasLen, 4)
+	c.Assert(output.ShardIndexes, qt.HasLen, 2)
+	c.Assert(output.ShardIndexes["xxhash_product_id"].Columns, qt.DeepEquals, []string{"product_id"})
+	c.Assert(buf.String(), qt.Not(qt.Contains), `"tree"`)
+}
+
+func TestBranch_DataTopologyListCmd_JSON_Shards(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	topology := &ps.DataTopology{DataTopology: json.RawMessage(dataTopologyDiagramFixture)}
+	svc := &mock.DatabaseBranchesService{
+		DataTopologyFn: func(ctx context.Context, req *ps.BranchDataTopologyRequest) (*ps.DataTopology, error) {
+			return topology, nil
+		},
+	}
+	ch := dataTopologyTestHelper("my-org", printer.JSON, &buf, svc)
+
+	cmd := ListDataTopologyCmd(ch)
+	cmd.SetArgs([]string{"my-db", "main", "--shards"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	var output dataTopologyShardsOutput
+	c.Assert(json.Unmarshal(buf.Bytes(), &output), qt.IsNil)
+	c.Assert(output.Organization, qt.Equals, "my-org")
+	c.Assert(output.Database, qt.Equals, "my-db")
+	c.Assert(output.Branch, qt.Equals, "main")
+	c.Assert(output.AuthoritativeShardGroup, qt.Equals, "authoritative")
+	c.Assert(output.Shards, qt.HasLen, 5)
+	c.Assert(output.Shards["shard-a"].Placements, qt.HasLen, 2)
+	start, end := "00", "40"
+	c.Assert(output.Shards["shard-a"].Placements[0], qt.DeepEquals, dataTopologyPlacement{
+		ShardGroup:        "catalog",
+		KeyRange:          dataTopologyKeyRangeOutput{Start: &start, End: &end},
+		DefaultShardIndex: "xxhash_product_id",
+		Tables: []dataTopologyHostedRelation{
+			{Database: "commerce", Schema: "public", Name: "price_history"},
+			{Database: "commerce", Schema: "public", Name: "products"},
+		},
+	})
+	c.Assert(output.Shards["shard-meta"].Placements, qt.DeepEquals, []dataTopologyPlacement{
+		{
+			ShardGroup:    "authoritative",
+			Authoritative: true,
+			KeyRange:      dataTopologyKeyRangeOutput{},
+			Tables: []dataTopologyHostedRelation{
+				{Database: "commerce", Schema: "public", Name: "countries"},
+			},
+		},
+	})
+	c.Assert(buf.String(), qt.Not(qt.Contains), `"tree"`)
+}
+
+func TestBranch_DataTopologyUpdateCmd(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	raw := `{"authoritative_shard_group":"default","shard_groups":[]}`
+	syncedAt := time.Date(2026, time.August, 3, 12, 0, 0, 0, time.UTC)
+	topology := &ps.DataTopology{
+		ID:           "topology-id",
+		Type:         "NekiDataTopology",
+		DataTopology: json.RawMessage(raw),
+		SyncedAt:     &syncedAt,
+	}
+	svc := &mock.DatabaseBranchesService{
+		UpdateDataTopologyFn: func(ctx context.Context, req *ps.UpdateBranchDataTopologyRequest) (*ps.DataTopology, error) {
+			c.Assert(req.Organization, qt.Equals, "my-org")
+			c.Assert(req.Database, qt.Equals, "my-db")
+			c.Assert(req.Branch, qt.Equals, "main")
+			c.Assert(string(req.DataTopology), qt.JSONEquals, map[string]any{
+				"authoritative_shard_group": "default",
+				"shard_groups":              []any{},
+			})
+			return topology, nil
+		},
+	}
+	ch := dataTopologyTestHelper("my-org", printer.JSON, &buf, svc)
+
+	cmd := UpdateDataTopologyCmd(ch)
+	cmd.SetIn(strings.NewReader(raw))
+	cmd.SetArgs([]string{"my-db", "main"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(svc.UpdateDataTopologyFnInvoked, qt.IsTrue)
+	c.Assert(buf.String(), qt.JSONEquals, topology)
+}
+
+func TestBranch_DataTopologyUpdateCmd_RequiresStdin(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	ch := dataTopologyTestHelper("my-org", printer.JSON, &buf, &mock.DatabaseBranchesService{})
+
+	cmd := UpdateDataTopologyCmd(ch)
+	cmd.SetIn(strings.NewReader(""))
+	cmd.SetArgs([]string{"my-db", "main"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.ErrorMatches, "no data topology provided; pipe a JSON object to standard input")
+}
+
+func TestBranch_DataTopologyUpdateCmd_RequiresJSONObject(t *testing.T) {
+	c := qt.New(t)
+
+	for _, input := range []string{"not-json", `[]`, `null`} {
+		c.Run(input, func(c *qt.C) {
+			var buf bytes.Buffer
+			ch := dataTopologyTestHelper("my-org", printer.JSON, &buf, &mock.DatabaseBranchesService{})
+
+			cmd := UpdateDataTopologyCmd(ch)
+			cmd.SetIn(strings.NewReader(input))
+			cmd.SetArgs([]string{"my-db", "main"})
+			err := cmd.Execute()
+
+			c.Assert(err, qt.IsNotNil)
+			c.Assert(err.Error(), qt.Contains, "invalid data topology JSON")
+		})
+	}
+}
diff --git a/internal/cmd/branch/data_topology_tree.go b/internal/cmd/branch/data_topology_tree.go
new file mode 100644
index 000000000..591e58ee4
--- /dev/null
+++ b/internal/cmd/branch/data_topology_tree.go
@@ -0,0 +1,593 @@
+package branch
+
+import (
+	"encoding/json"
+	"fmt"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/planetscale/cli/internal/planetscale"
+)
+
+type dataTopologyTreeOutput struct {
+	Database string                `json:"database"`
+	Branch   string                `json:"branch"`
+	SyncedAt *time.Time            `json:"synced_at"`
+	Tree     *dataTopologyTreeNode `json:"tree"`
+}
+
+type dataTopologyTreeNode struct {
+	Name     string                  `json:"name"`
+	Children []*dataTopologyTreeNode `json:"children,omitempty"`
+}
+
+type dataTopologyDocument struct {
+	AuthoritativeShardGroup string                            `json:"authoritative_shard_group"`
+	ShardIndexes            map[string]dataTopologyShardIndex `json:"shard_indexes"`
+	ShardGroups             []dataTopologyShardGroup          `json:"shard_groups"`
+	Databases               map[string]dataTopologyDatabase   `json:"databases"`
+}
+
+type dataTopologyShardIndex struct {
+	Type        string            `json:"type"`
+	Columns     []string          `json:"columns,omitempty"`
+	IndexParams map[string]string `json:"index_params,omitempty"`
+}
+
+type dataTopologyShardGroup struct {
+	UID               string                 `json:"uid"`
+	Name              string                 `json:"name,omitempty"`
+	DefaultShardIndex string                 `json:"default_shard_index,omitempty"`
+	KeyRanges         []dataTopologyKeyRange `json:"key_ranges,omitempty"`
+}
+
+type dataTopologyKeyRange struct {
+	ShardUID string `json:"shard_uid"`
+	Start    string `json:"start,omitempty"`
+	End      string `json:"end,omitempty"`
+}
+
+type dataTopologyDatabase struct {
+	AuthoritativeShardGroup string                             `json:"authoritative_shard_group,omitempty"`
+	DefaultShardGroup       string                             `json:"default_shard_group,omitempty"`
+	GlobalSecondaryIndexes  map[string]dataTopologyGlobalIndex `json:"global_secondary_indexes,omitempty"`
+	Schemas                 map[string]dataTopologySchema      `json:"schemas,omitempty"`
+}
+
+type dataTopologySchema struct {
+	DefaultShardGroup string                                `json:"default_shard_group,omitempty"`
+	Tables            map[string]dataTopologyTable          `json:"tables,omitempty"`
+	Sequences         []dataTopologySequence                `json:"sequences,omitempty"`
+	ReferenceTables   map[string]dataTopologyReferenceTable `json:"reference_tables,omitempty"`
+}
+
+type dataTopologySequence struct {
+	Name          string `json:"name"`
+	ShardGroupUID string `json:"shard_group_uid,omitempty"`
+}
+
+type dataTopologyTable struct {
+	ShardGroupUID    string                       `json:"shard_group_uid,omitempty"`
+	PrimaryIndexes   []dataTopologyPrimaryIndex   `json:"primary_indexes,omitempty"`
+	SecondaryIndexes []dataTopologySecondaryIndex `json:"secondary_indexes,omitempty"`
+}
+
+type dataTopologyPrimaryIndex struct {
+	ShardIndex string   `json:"shard_index,omitempty"`
+	Columns    []string `json:"columns,omitempty"`
+	IgnoreNull bool     `json:"ignore_null,omitempty"`
+}
+
+type dataTopologySecondaryIndex struct {
+	Name    string   `json:"name"`
+	Columns []string `json:"columns,omitempty"`
+}
+
+type dataTopologyReferenceTable struct {
+	ShardGroupUIDs []string `json:"shard_group_uids,omitempty"`
+}
+
+type dataTopologyGlobalIndex struct {
+	Schema         string   `json:"schema,omitempty"`
+	Table          string   `json:"table"`
+	OwnerTable     string   `json:"owner_table"`
+	Columns        []string `json:"columns"`
+	OwnerPKColumns []string `json:"owner_pk_columns,omitempty"`
+	Unique         bool     `json:"unique,omitempty"`
+	IgnoreNull     bool     `json:"ignore_null,omitempty"`
+	Enabled        bool     `json:"enabled,omitempty"`
+}
+
+func buildDataTopologyTree(organization, database, branch string, dataTopology *planetscale.DataTopology) (*dataTopologyTreeOutput, error) {
+	document, err := parseDataTopologyDocument(dataTopology)
+	if err != nil {
+		return nil, err
+	}
+
+	root := &dataTopologyTreeNode{Name: organization + "/" + database + "/" + branch}
+	if len(document.Databases) > 0 {
+		root.Children = append(root.Children, databasesTree(document))
+	}
+	if len(document.ShardGroups) > 0 {
+		root.Children = append(root.Children, shardGroupsTree(document))
+	}
+	if len(document.ShardIndexes) > 0 {
+		root.Children = append(root.Children, shardIndexesTree(document))
+	}
+
+	return newDataTopologyTreeOutput(database, branch, dataTopology, root), nil
+}
+
+func buildDataTopologyShardsTree(organization, database, branch string, dataTopology *planetscale.DataTopology) (*dataTopologyTreeOutput, error) {
+	document, err := parseDataTopologyDocument(dataTopology)
+	if err != nil {
+		return nil, err
+	}
+
+	root := &dataTopologyTreeNode{Name: organization + "/" + database + "/" + branch}
+	root.Children = shardNodes(document)
+	return newDataTopologyTreeOutput(database, branch, dataTopology, root), nil
+}
+
+func parseDataTopologyDocument(dataTopology *planetscale.DataTopology) (*dataTopologyDocument, error) {
+	var document dataTopologyDocument
+	if err := json.Unmarshal(dataTopology.DataTopology, &document); err != nil {
+		return nil, fmt.Errorf("reading data topology: %w", err)
+	}
+	return &document, nil
+}
+
+func newDataTopologyTreeOutput(database, branch string, dataTopology *planetscale.DataTopology, root *dataTopologyTreeNode) *dataTopologyTreeOutput {
+	return &dataTopologyTreeOutput{
+		Database: database,
+		Branch:   branch,
+		SyncedAt: dataTopology.SyncedAt,
+		Tree:     root,
+	}
+}
+
+type dataTopologyShardPlacement struct {
+	Group    dataTopologyShardGroup
+	KeyRange dataTopologyKeyRange
+}
+
+type dataTopologyHostedRelation struct {
+	Database string `json:"database"`
+	Schema   string `json:"schema"`
+	Name     string `json:"name"`
+}
+
+type dataTopologyHostedData struct {
+	Tables          []dataTopologyHostedRelation `json:"tables,omitempty"`
+	ReferenceTables []dataTopologyHostedRelation `json:"reference_tables,omitempty"`
+	Sequences       []dataTopologyHostedRelation `json:"sequences,omitempty"`
+}
+
+func shardNodes(document *dataTopologyDocument) []*dataTopologyTreeNode {
+	var nodes []*dataTopologyTreeNode
+	placements := shardPlacementsByUID(document)
+	hostedData := dataHostedByShardGroup(document)
+	for _, shardUID := range sortedKeys(placements) {
+		shardNode := &dataTopologyTreeNode{Name: shardUID}
+		for _, placement := range placements[shardUID] {
+			label := placement.Group.UID + " " + formatKeyRangeBounds(placement.KeyRange)
+			if placement.Group.UID == document.AuthoritativeShardGroup {
+				label += " [authoritative]"
+			}
+			groupNode := &dataTopologyTreeNode{Name: label}
+			for _, data := range hostedData[placement.Group.UID].labels() {
+				groupNode.add(data)
+			}
+			shardNode.Children = append(shardNode.Children, groupNode)
+		}
+		nodes = append(nodes, shardNode)
+	}
+	return nodes
+}
+
+func shardPlacementsByUID(document *dataTopologyDocument) map[string][]dataTopologyShardPlacement {
+	placements := make(map[string][]dataTopologyShardPlacement)
+	for _, group := range document.ShardGroups {
+		for _, keyRange := range group.KeyRanges {
+			placements[keyRange.ShardUID] = append(placements[keyRange.ShardUID], dataTopologyShardPlacement{
+				Group:    group,
+				KeyRange: keyRange,
+			})
+		}
+	}
+
+	for shardUID, shardPlacements := range placements {
+		slices.SortFunc(shardPlacements, func(a, b dataTopologyShardPlacement) int {
+			if result := strings.Compare(a.Group.UID, b.Group.UID); result != 0 {
+				return result
+			}
+			if result := strings.Compare(a.KeyRange.Start, b.KeyRange.Start); result != 0 {
+				return result
+			}
+			return strings.Compare(a.KeyRange.End, b.KeyRange.End)
+		})
+		placements[shardUID] = shardPlacements
+	}
+	return placements
+}
+
+func dataHostedByShardGroup(document *dataTopologyDocument) map[string]dataTopologyHostedData {
+	hostedData := make(map[string]dataTopologyHostedData)
+	for _, databaseName := range sortedKeys(document.Databases) {
+		database := document.Databases[databaseName]
+		for _, schemaName := range sortedKeys(database.Schemas) {
+			schema := database.Schemas[schemaName]
+			for _, tableName := range sortedKeys(schema.Tables) {
+				group, _ := resolveTableShardGroup(schemaName, schema.Tables[tableName], schema, database, document.AuthoritativeShardGroup)
+				if group != "<unresolved>" {
+					data := hostedData[group]
+					data.Tables = append(data.Tables, dataTopologyHostedRelation{Database: databaseName, Schema: schemaName, Name: tableName})
+					hostedData[group] = data
+				}
+			}
+			for _, sequence := range schema.Sequences {
+				group, _ := resolveSequenceShardGroup(sequence, database, document.AuthoritativeShardGroup)
+				if group != "<unresolved>" {
+					data := hostedData[group]
+					data.Sequences = append(data.Sequences, dataTopologyHostedRelation{Database: databaseName, Schema: schemaName, Name: sequence.Name})
+					hostedData[group] = data
+				}
+			}
+			for _, tableName := range sortedKeys(schema.ReferenceTables) {
+				for _, group := range resolveReferenceTableShardGroups(schema.ReferenceTables[tableName], schema, database) {
+					data := hostedData[group]
+					data.ReferenceTables = append(data.ReferenceTables, dataTopologyHostedRelation{Database: databaseName, Schema: schemaName, Name: tableName})
+					hostedData[group] = data
+				}
+			}
+		}
+	}
+
+	for group, data := range hostedData {
+		data.Tables = sortAndCompactHostedRelations(data.Tables)
+		data.ReferenceTables = sortAndCompactHostedRelations(data.ReferenceTables)
+		data.Sequences = sortAndCompactHostedRelations(data.Sequences)
+		hostedData[group] = data
+	}
+	return hostedData
+}
+
+func sortAndCompactHostedRelations(relations []dataTopologyHostedRelation) []dataTopologyHostedRelation {
+	slices.SortFunc(relations, func(a, b dataTopologyHostedRelation) int {
+		if result := strings.Compare(a.Database, b.Database); result != 0 {
+			return result
+		}
+		if result := strings.Compare(a.Schema, b.Schema); result != 0 {
+			return result
+		}
+		return strings.Compare(a.Name, b.Name)
+	})
+	return slices.Compact(relations)
+}
+
+func (d dataTopologyHostedData) labels() []string {
+	labels := make([]string, 0, len(d.Tables)+len(d.ReferenceTables)+len(d.Sequences))
+	for _, table := range d.Tables {
+		labels = append(labels, table.path())
+	}
+	for _, table := range d.ReferenceTables {
+		labels = append(labels, table.path()+" [reference]")
+	}
+	for _, sequence := range d.Sequences {
+		labels = append(labels, sequence.path()+" [sequence]")
+	}
+	slices.Sort(labels)
+	return labels
+}
+
+func (r dataTopologyHostedRelation) path() string {
+	return r.Database + "." + r.Schema + "." + r.Name
+}
+
+func databasesTree(document *dataTopologyDocument) *dataTopologyTreeNode {
+	root := &dataTopologyTreeNode{Name: "databases"}
+	for _, databaseName := range sortedKeys(document.Databases) {
+		database := document.Databases[databaseName]
+		node := &dataTopologyTreeNode{Name: databaseName}
+		if database.AuthoritativeShardGroup != "" {
+			node.add("authoritative shard group → " + database.AuthoritativeShardGroup)
+		}
+		if database.DefaultShardGroup != "" {
+			node.add("default shard group → " + database.DefaultShardGroup)
+		}
+		if len(database.GlobalSecondaryIndexes) > 0 {
+			node.Children = append(node.Children, globalIndexesTree(database.GlobalSecondaryIndexes))
+		}
+		if len(database.Schemas) > 0 {
+			node.Children = append(node.Children, schemasTree(database, document.AuthoritativeShardGroup))
+		}
+		root.Children = append(root.Children, node)
+	}
+	return root
+}
+
+func globalIndexesTree(indexes map[string]dataTopologyGlobalIndex) *dataTopologyTreeNode {
+	root := &dataTopologyTreeNode{Name: "global secondary indexes"}
+	for _, name := range sortedKeys(indexes) {
+		index := indexes[name]
+		schema := index.Schema
+		if schema == "" {
+			schema = "public"
+		}
+		label := fmt.Sprintf("%s: %s(%s) → %s.%s", name, index.OwnerTable, strings.Join(index.Columns, ", "), schema, index.Table)
+		var attributes []string
+		if index.Unique {
+			attributes = append(attributes, "unique")
+		}
+		if index.Enabled {
+			attributes = append(attributes, "enabled")
+		}
+		if len(attributes) > 0 {
+			label += " [" + strings.Join(attributes, ", ") + "]"
+		}
+		root.add(label)
+	}
+	return root
+}
+
+func schemasTree(database dataTopologyDatabase, clusterAuthoritativeGroup string) *dataTopologyTreeNode {
+	root := &dataTopologyTreeNode{Name: "schemas"}
+	for _, schemaName := range sortedKeys(database.Schemas) {
+		schema := database.Schemas[schemaName]
+		node := &dataTopologyTreeNode{Name: schemaName}
+		if schema.DefaultShardGroup != "" {
+			node.add("default shard group → " + schema.DefaultShardGroup)
+		}
+		if len(schema.Tables) > 0 {
+			node.Children = append(node.Children, tablesTree(schemaName, schema, database, clusterAuthoritativeGroup))
+		}
+		if len(schema.Sequences) > 0 {
+			node.Children = append(node.Children, sequencesTree(schema, database, clusterAuthoritativeGroup))
+		}
+		if len(schema.ReferenceTables) > 0 {
+			node.Children = append(node.Children, referenceTablesTree(schema, database))
+		}
+		root.Children = append(root.Children, node)
+	}
+	return root
+}
+
+func sequencesTree(schema dataTopologySchema, database dataTopologyDatabase, clusterAuthoritativeGroup string) *dataTopologyTreeNode {
+	root := &dataTopologyTreeNode{Name: "sequences"}
+	sequences := slices.Clone(schema.Sequences)
+	slices.SortFunc(sequences, func(a, b dataTopologySequence) int {
+		return strings.Compare(a.Name, b.Name)
+	})
+	for _, sequence := range sequences {
+		group, source := resolveSequenceShardGroup(sequence, database, clusterAuthoritativeGroup)
+		label := sequence.Name + " → " + group
+		if source != "" {
+			label += " (" + source + ")"
+		}
+		root.add(label)
+	}
+	return root
+}
+
+func resolveSequenceShardGroup(sequence dataTopologySequence, database dataTopologyDatabase, clusterAuthoritativeGroup string) (string, string) {
+	if sequence.ShardGroupUID != "" {
+		return sequence.ShardGroupUID, "sequence"
+	}
+	if database.AuthoritativeShardGroup != "" {
+		return database.AuthoritativeShardGroup, "database authoritative"
+	}
+	if clusterAuthoritativeGroup != "" {
+		return clusterAuthoritativeGroup, "cluster authoritative"
+	}
+	return "<unresolved>", ""
+}
+
+func tablesTree(schemaName string, schema dataTopologySchema, database dataTopologyDatabase, clusterAuthoritativeGroup string) *dataTopologyTreeNode {
+	root := &dataTopologyTreeNode{Name: "tables"}
+	for _, tableName := range sortedKeys(schema.Tables) {
+		table := schema.Tables[tableName]
+		group, source := resolveTableShardGroup(schemaName, table, schema, database, clusterAuthoritativeGroup)
+		label := tableName + " → " + group
+		if source != "" && source != "table" {
+			label += " (" + source + ")"
+		}
+		node := &dataTopologyTreeNode{Name: label}
+
+		for _, index := range table.PrimaryIndexes {
+			label := "primary index"
+			if index.ShardIndex != "" {
+				label += " → " + index.ShardIndex
+			}
+			if len(index.Columns) > 0 {
+				label += " (" + strings.Join(index.Columns, ", ") + ")"
+			}
+			if index.IgnoreNull {
+				label += " [ignore null]"
+			}
+			node.add(label)
+		}
+
+		for _, index := range table.SecondaryIndexes {
+			label := "secondary index → " + index.Name
+			if len(index.Columns) > 0 {
+				label += " (" + strings.Join(index.Columns, ", ") + ")"
+			}
+			if globalIndex, ok := database.GlobalSecondaryIndexes[index.Name]; ok {
+				schema := globalIndex.Schema
+				if schema == "" {
+					schema = "public"
+				}
+				label += " → " + schema + "." + globalIndex.Table
+			}
+			node.add(label)
+		}
+
+		root.Children = append(root.Children, node)
+	}
+	return root
+}
+
+func resolveTableShardGroup(schemaName string, table dataTopologyTable, schema dataTopologySchema, database dataTopologyDatabase, clusterAuthoritativeGroup string) (string, string) {
+	if table.ShardGroupUID != "" {
+		return table.ShardGroupUID, "table"
+	}
+	if schema.DefaultShardGroup != "" {
+		return schema.DefaultShardGroup, "schema default"
+	}
+	if database.DefaultShardGroup != "" {
+		return database.DefaultShardGroup, "database default"
+	}
+	if isSystemSchema(schemaName) {
+		if database.AuthoritativeShardGroup != "" {
+			return database.AuthoritativeShardGroup, "database authoritative"
+		}
+		if clusterAuthoritativeGroup != "" {
+			return clusterAuthoritativeGroup, "cluster authoritative"
+		}
+	}
+	return "<unresolved>", ""
+}
+
+func referenceTablesTree(schema dataTopologySchema, database dataTopologyDatabase) *dataTopologyTreeNode {
+	root := &dataTopologyTreeNode{Name: "reference tables"}
+	for _, tableName := range sortedKeys(schema.ReferenceTables) {
+		groups := resolveReferenceTableShardGroups(schema.ReferenceTables[tableName], schema, database)
+		label := tableName + " → "
+		if len(groups) == 0 {
+			label += "<unresolved>"
+		} else {
+			label += strings.Join(groups, ", ")
+		}
+		root.add(label)
+	}
+	return root
+}
+
+func resolveReferenceTableShardGroups(referenceTable dataTopologyReferenceTable, schema dataTopologySchema, database dataTopologyDatabase) []string {
+	groups := slices.Clone(referenceTable.ShardGroupUIDs)
+	if len(groups) == 0 {
+		if schema.DefaultShardGroup != "" {
+			groups = []string{schema.DefaultShardGroup}
+		} else if database.DefaultShardGroup != "" {
+			groups = []string{database.DefaultShardGroup}
+		}
+	}
+	slices.Sort(groups)
+	return slices.Compact(groups)
+}
+
+func shardGroupsTree(document *dataTopologyDocument) *dataTopologyTreeNode {
+	root := &dataTopologyTreeNode{Name: "shard groups"}
+	groups := slices.Clone(document.ShardGroups)
+	slices.SortFunc(groups, func(a, b dataTopologyShardGroup) int {
+		return strings.Compare(a.UID, b.UID)
+	})
+
+	for _, group := range groups {
+		label := group.UID
+		if group.Name != "" && group.Name != group.UID {
+			label += " (" + group.Name + ")"
+		}
+		if group.DefaultShardIndex != "" {
+			label += " → " + group.DefaultShardIndex
+		}
+		if group.UID == document.AuthoritativeShardGroup {
+			label += " [authoritative]"
+		}
+		node := &dataTopologyTreeNode{Name: label}
+		if len(group.KeyRanges) > 0 {
+			ranges := &dataTopologyTreeNode{Name: "key ranges"}
+			for _, keyRange := range group.KeyRanges {
+				ranges.add(formatKeyRange(keyRange))
+			}
+			node.Children = append(node.Children, ranges)
+		}
+		root.Children = append(root.Children, node)
+	}
+	return root
+}
+
+func shardIndexesTree(document *dataTopologyDocument) *dataTopologyTreeNode {
+	root := &dataTopologyTreeNode{Name: "shard indexes"}
+	for _, name := range sortedKeys(document.ShardIndexes) {
+		index := document.ShardIndexes[name]
+		label := name + ": " + index.Type
+		if len(index.Columns) > 0 {
+			label += "(" + strings.Join(index.Columns, ", ") + ")"
+		}
+		if len(index.IndexParams) > 0 {
+			var params []string
+			for _, key := range sortedKeys(index.IndexParams) {
+				params = append(params, key+"="+index.IndexParams[key])
+			}
+			label += " [" + strings.Join(params, ", ") + "]"
+		}
+		root.add(label)
+	}
+	return root
+}
+
+func formatKeyRange(keyRange dataTopologyKeyRange) string {
+	return fmt.Sprintf("%s → %s", formatKeyRangeBounds(keyRange), keyRange.ShardUID)
+}
+
+func formatKeyRangeBounds(keyRange dataTopologyKeyRange) string {
+	start := keyRange.Start
+	if start == "" {
+		start = "-∞"
+	}
+	end := keyRange.End
+	if end == "" {
+		end = "+∞"
+	}
+	return fmt.Sprintf("[%s, %s)", start, end)
+}
+
+func isSystemSchema(name string) bool {
+	return name == "pg_catalog" || name == "information_schema" || name == "pg_toast"
+}
+
+func renderDataTopologyTree(root *dataTopologyTreeNode) string {
+	var output strings.Builder
+	output.WriteString(root.Name)
+	output.WriteByte('\n')
+	for i, child := range root.Children {
+		renderDataTopologyTreeNode(&output, child, "", i == len(root.Children)-1)
+	}
+	return output.String()
+}
+
+func renderDataTopologyTreeNode(output *strings.Builder, node *dataTopologyTreeNode, prefix string, last bool) {
+	output.WriteString(prefix)
+	if last {
+		output.WriteString("└── ")
+	} else {
+		output.WriteString("├── ")
+	}
+	output.WriteString(node.Name)
+	output.WriteByte('\n')
+
+	childPrefix := prefix
+	if last {
+		childPrefix += "    "
+	} else {
+		childPrefix += "│   "
+	}
+	for i, child := range node.Children {
+		renderDataTopologyTreeNode(output, child, childPrefix, i == len(node.Children)-1)
+	}
+}
+
+func (n *dataTopologyTreeNode) add(name string) {
+	n.Children = append(n.Children, &dataTopologyTreeNode{Name: name})
+}
+
+func sortedKeys[V any](values map[string]V) []string {
+	keys := make([]string, 0, len(values))
+	for key := range values {
+		keys = append(keys, key)
+	}
+	slices.Sort(keys)
+	return keys
+}
diff --git a/internal/cmd/branch/diff.go b/internal/cmd/branch/diff.go
index cfd9adf9e..680afd7bf 100644
--- a/internal/cmd/branch/diff.go
+++ b/internal/cmd/branch/diff.go
@@ -21,7 +21,7 @@ func DiffCmd(ch *cmdutil.Helper) *cobra.Command {
 
 	cmd := &cobra.Command{
 		Use:   "diff <database> <branch>",
-		Short: "Show the diff of a branch",
+		Short: "Show the schema diff of a MySQL branch",
 		Args:  cmdutil.RequiredArgs("database", "branch"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
diff --git a/internal/cmd/branch/lint.go b/internal/cmd/branch/lint.go
index bac987ae6..26ef2e2ed 100644
--- a/internal/cmd/branch/lint.go
+++ b/internal/cmd/branch/lint.go
@@ -26,7 +26,7 @@ type SchemaLintError struct {
 func LintCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "lint <database> <branch>",
-		Short: "Lints the schema for a branch",
+		Short: "Lint the schema of a MySQL branch",
 		Args:  cmdutil.RequiredArgs("database", "branch"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
diff --git a/internal/cmd/branch/maintenance.go b/internal/cmd/branch/maintenance.go
index 31fbc6805..3d4e16b5f 100644
--- a/internal/cmd/branch/maintenance.go
+++ b/internal/cmd/branch/maintenance.go
@@ -9,12 +9,12 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// MaintenanceCmd groups the maintenance commands for a Postgres branch.
+// MaintenanceCmd groups the maintenance commands for a Postgres or Neki branch.
 func MaintenanceCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "maintenance <command>",
-		Short: "Run maintenance for a Postgres branch",
-		Long: `Manage maintenance for a Postgres branch.
+		Short: "Run maintenance for a Postgres or Neki branch",
+		Long: `Manage maintenance for a Postgres or Neki branch.
 
 PlanetScale upgrades a branch's image in emergencies, such as patching security
 issues, or when you initiate the upgrade yourself. 'maintenance run' initiates
@@ -28,7 +28,7 @@ See https://planetscale.com/docs/postgres/operations-philosophy`,
 	return cmd
 }
 
-// MaintenanceRunCmd starts a maintenance run for a Postgres branch.
+// MaintenanceRunCmd starts a maintenance run for a Postgres or Neki branch.
 func MaintenanceRunCmd(ch *cmdutil.Helper) *cobra.Command {
 	var flags struct {
 		updatePostgresMinorVersion bool
@@ -36,9 +36,9 @@ func MaintenanceRunCmd(ch *cmdutil.Helper) *cobra.Command {
 
 	cmd := &cobra.Command{
 		Use:   "run <database> <branch>",
-		Short: "Run maintenance for a Postgres branch now (Postgres only)",
-		Long: `Run maintenance for a Postgres branch, updating it to the latest available
-image. Postgres only.
+		Short: "Run maintenance for a Postgres or Neki branch now",
+		Long: `Run maintenance for a Postgres or Neki branch, updating it to the latest
+available image. Vitess (MySQL) databases are not supported.
 
 This is how regular version bumps, bugfixes, and quality-of-life improvements
 reach a branch. PlanetScale otherwise upgrades images only in emergencies, such
@@ -67,7 +67,7 @@ See https://planetscale.com/docs/postgres/operations-philosophy`,
 				return err
 			}
 
-			if err := cmdutil.RequirePostgresDatabase(ctx, client, ch.Config.Organization, database, "Maintenance runs"); err != nil {
+			if err := cmdutil.RequirePostgresOrNekiDatabase(ctx, client, ch.Config.Organization, database, "Maintenance runs"); err != nil {
 				return err
 			}
 
@@ -101,8 +101,9 @@ See https://planetscale.com/docs/postgres/operations-philosophy`,
 			}
 
 			return ch.Printer.PrintResource(map[string]string{
-				"result": "maintenance started",
-				"branch": branch,
+				"result":   "maintenance started",
+				"database": database,
+				"branch":   branch,
 			})
 		},
 	}
diff --git a/internal/cmd/branch/maintenance_test.go b/internal/cmd/branch/maintenance_test.go
index 887d1c1bd..b98460bbf 100644
--- a/internal/cmd/branch/maintenance_test.go
+++ b/internal/cmd/branch/maintenance_test.go
@@ -13,136 +13,97 @@ import (
 	"github.com/planetscale/cli/internal/printer"
 )
 
-func TestBranch_MaintenanceRunCmd(t *testing.T) {
-	c := qt.New(t)
-
-	var buf bytes.Buffer
+func maintenanceTestHelper(out *bytes.Buffer, kind ps.DatabaseEngine, svc *mock.BranchMaintenanceService) *cmdutil.Helper {
 	format := printer.JSON
 	p := printer.NewPrinter(&format)
-	p.SetResourceOutput(&buf)
-
-	org := "planetscale"
-	db := "planetscale"
-	branch := "main"
+	p.SetResourceOutput(out)
 
 	dbSvc := &mock.DatabaseService{
-		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
-			return &ps.Database{Name: db, Kind: ps.DatabaseEnginePostgres}, nil
+		GetFn: func(_ context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
+			return &ps.Database{Name: req.Database, Kind: kind}, nil
 		},
 	}
-	svc := &mock.BranchMaintenanceService{
-		RunFn: func(ctx context.Context, req *ps.RunBranchMaintenanceRequest) error {
-			c.Assert(req.Organization, qt.Equals, org)
-			c.Assert(req.Database, qt.Equals, db)
-			c.Assert(req.Branch, qt.Equals, branch)
-			c.Assert(req.UpdatePostgresMinorVersion, qt.IsFalse)
 
-			return nil
-		},
-	}
-
-	ch := &cmdutil.Helper{
+	return &cmdutil.Helper{
 		Printer: p,
-		Config: &config.Config{
-			Organization: org,
-		},
+		Config:  &config.Config{Organization: "acme"},
 		Client: func() (*ps.Client, error) {
-			return &ps.Client{
-				Databases:         dbSvc,
-				BranchMaintenance: svc,
-			}, nil
+			return &ps.Client{Databases: dbSvc, BranchMaintenance: svc}, nil
 		},
 	}
+}
 
-	cmd := MaintenanceRunCmd(ch)
-	cmd.SetArgs([]string{db, branch})
-	err := cmd.Execute()
-
-	c.Assert(err, qt.IsNil)
-	c.Assert(svc.RunFnInvoked, qt.IsTrue)
-	c.Assert(buf.String(), qt.JSONEquals, map[string]string{
-		"result": "maintenance started",
-		"branch": branch,
-	})
+func TestMaintenanceRunCmd(t *testing.T) {
+	for _, kind := range []ps.DatabaseEngine{ps.DatabaseEngineNeki, ps.DatabaseEnginePostgres} {
+		t.Run(string(kind), func(t *testing.T) {
+			c := qt.New(t)
+			var out bytes.Buffer
+			svc := &mock.BranchMaintenanceService{
+				RunFn: func(_ context.Context, req *ps.RunBranchMaintenanceRequest) error {
+					c.Assert(req, qt.DeepEquals, &ps.RunBranchMaintenanceRequest{
+						Organization: "acme",
+						Database:     "app",
+						Branch:       "main",
+					})
+					return nil
+				},
+			}
+
+			cmd := MaintenanceRunCmd(maintenanceTestHelper(&out, kind, svc))
+			cmd.SetArgs([]string{"app", "main"})
+
+			c.Assert(cmd.Execute(), qt.IsNil)
+			c.Assert(svc.RunFnInvoked, qt.IsTrue)
+			c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+				"result":   "maintenance started",
+				"database": "app",
+				"branch":   "main",
+			})
+		})
+	}
 }
 
-func TestBranch_MaintenanceRunCmd_UpdateMinorVersion(t *testing.T) {
+func TestMaintenanceRunCmdUpdatesPostgresMinorVersion(t *testing.T) {
 	c := qt.New(t)
-
-	var buf bytes.Buffer
-	format := printer.JSON
-	p := printer.NewPrinter(&format)
-	p.SetResourceOutput(&buf)
-
-	dbSvc := &mock.DatabaseService{
-		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
-			return &ps.Database{Name: req.Database, Kind: ps.DatabaseEnginePostgres}, nil
-		},
-	}
+	var out bytes.Buffer
 	svc := &mock.BranchMaintenanceService{
-		RunFn: func(ctx context.Context, req *ps.RunBranchMaintenanceRequest) error {
+		RunFn: func(_ context.Context, req *ps.RunBranchMaintenanceRequest) error {
 			c.Assert(req.UpdatePostgresMinorVersion, qt.IsTrue)
 			return nil
 		},
 	}
 
-	ch := &cmdutil.Helper{
-		Printer: p,
-		Config: &config.Config{
-			Organization: "planetscale",
-		},
-		Client: func() (*ps.Client, error) {
-			return &ps.Client{
-				Databases:         dbSvc,
-				BranchMaintenance: svc,
-			}, nil
-		},
-	}
+	cmd := MaintenanceRunCmd(maintenanceTestHelper(&out, ps.DatabaseEnginePostgres, svc))
+	cmd.SetArgs([]string{"app", "main", "--update-postgres-minor-version"})
 
-	cmd := MaintenanceRunCmd(ch)
-	cmd.SetArgs([]string{"planetscale", "main", "--update-postgres-minor-version"})
-	err := cmd.Execute()
-
-	c.Assert(err, qt.IsNil)
+	c.Assert(cmd.Execute(), qt.IsNil)
 	c.Assert(svc.RunFnInvoked, qt.IsTrue)
 }
 
-func TestBranch_MaintenanceRunCmd_VitessDatabase(t *testing.T) {
+func TestMaintenanceRunCmdRejectsVitessDatabases(t *testing.T) {
 	c := qt.New(t)
-
-	var buf bytes.Buffer
-	format := printer.JSON
-	p := printer.NewPrinter(&format)
-	p.SetResourceOutput(&buf)
-
-	dbSvc := &mock.DatabaseService{
-		GetFn: func(ctx context.Context, req *ps.GetDatabaseRequest) (*ps.Database, error) {
-			return &ps.Database{Name: req.Database, Kind: ps.DatabaseEngineMySQL}, nil
-		},
-	}
+	var out bytes.Buffer
 	svc := &mock.BranchMaintenanceService{
-		RunFn: func(ctx context.Context, req *ps.RunBranchMaintenanceRequest) error {
+		RunFn: func(_ context.Context, _ *ps.RunBranchMaintenanceRequest) error {
 			return nil
 		},
 	}
 
-	ch := &cmdutil.Helper{
-		Printer: p,
-		Config: &config.Config{
-			Organization: "planetscale",
-		},
-		Client: func() (*ps.Client, error) {
-			return &ps.Client{
-				Databases:         dbSvc,
-				BranchMaintenance: svc,
-			}, nil
-		},
-	}
+	cmd := MaintenanceRunCmd(maintenanceTestHelper(&out, ps.DatabaseEngineMySQL, svc))
+	cmd.SetArgs([]string{"app", "main"})
+
+	c.Assert(cmd.Execute(), qt.ErrorMatches, `(?s).*only available for Postgres and Neki.*mysql.*`)
+	c.Assert(svc.RunFnInvoked, qt.IsFalse)
+}
+
+func TestMaintenanceRunCmdRequiresBranch(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.BranchMaintenanceService{}
 
-	cmd := MaintenanceRunCmd(ch)
-	cmd.SetArgs([]string{"planetscale", "main"})
-	err := cmd.Execute()
+	cmd := MaintenanceRunCmd(maintenanceTestHelper(&out, ps.DatabaseEngineNeki, svc))
+	cmd.SetArgs([]string{"app"})
 
-	c.Assert(err, qt.ErrorMatches, `(?s).*only available for PostgreSQL.*mysql.*`)
+	c.Assert(cmd.Execute(), qt.IsNotNil)
 	c.Assert(svc.RunFnInvoked, qt.IsFalse)
 }
diff --git a/internal/cmd/branch/query_patterns.go b/internal/cmd/branch/query_patterns.go
index 723cff588..c35b16b90 100644
--- a/internal/cmd/branch/query_patterns.go
+++ b/internal/cmd/branch/query_patterns.go
@@ -21,7 +21,7 @@ var queryPatternsPollInterval = 2 * time.Second
 func QueryPatternsCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "query-patterns <command>",
-		Short: "List, show, delete, and download query pattern reports for a branch",
+		Short: "List, show, delete, and download query pattern reports for a MySQL branch",
 	}
 
 	cmd.AddCommand(ListQueryPatternsCmd(ch))
@@ -48,7 +48,7 @@ func DownloadQueryPatternsCmd(ch *cmdutil.Helper) *cobra.Command {
 
 	cmd := &cobra.Command{
 		Use:   "download <database> <branch>",
-		Short: "Download a CSV report of the query patterns for a branch",
+		Short: "Download a CSV report of the query patterns for a MySQL branch",
 		Args:  cmdutil.RequiredArgs("database", "branch"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
diff --git a/internal/cmd/branch/refresh_schema.go b/internal/cmd/branch/refresh_schema.go
index 2efc225fb..f50ea7b40 100644
--- a/internal/cmd/branch/refresh_schema.go
+++ b/internal/cmd/branch/refresh_schema.go
@@ -12,7 +12,7 @@ import (
 func RefreshSchemaCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "refresh-schema <database> <branch>",
-		Short: "Refresh the schema for a database branch",
+		Short: "Refresh the schema for a MySQL branch",
 		Args:  cmdutil.RequiredArgs("database", "branch"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
diff --git a/internal/cmd/branch/routing_rules.go b/internal/cmd/branch/routing_rules.go
index 0327ed65a..1347c7a9c 100644
--- a/internal/cmd/branch/routing_rules.go
+++ b/internal/cmd/branch/routing_rules.go
@@ -16,7 +16,7 @@ import (
 func RoutingRulesCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "routing-rules <command>",
-		Short: "Fetch or update your keyspace routing rules",
+		Short: "Fetch or update keyspace routing rules for a MySQL branch",
 	}
 
 	cmd.AddCommand(GetRoutingRulesCmd(ch))
@@ -29,7 +29,7 @@ func RoutingRulesCmd(ch *cmdutil.Helper) *cobra.Command {
 func GetRoutingRulesCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "get <database> <branch>",
-		Short: "Show the routing rules of a branch",
+		Short: "Show the routing rules of a MySQL branch",
 		Args:  cmdutil.RequiredArgs("database", "branch"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
@@ -79,7 +79,7 @@ func UpdateRoutingRulesCmd(ch *cmdutil.Helper) *cobra.Command {
 
 	cmd := &cobra.Command{
 		Use:   "update <database> <branch> --routing-rules <file>",
-		Short: "Update the routing rules of a branch",
+		Short: "Update the routing rules of a MySQL branch",
 		Args:  cmdutil.RequiredArgs("database", "branch"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
diff --git a/internal/cmd/branch/safe_migrations.go b/internal/cmd/branch/safe_migrations.go
index b9670c5b3..af2121542 100644
--- a/internal/cmd/branch/safe_migrations.go
+++ b/internal/cmd/branch/safe_migrations.go
@@ -15,7 +15,7 @@ import (
 func SafeMigrationsCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "safe-migrations <command>",
-		Short: "Enable or disable safe migrations on a branch",
+		Short: "Enable or disable safe migrations on a MySQL branch",
 	}
 
 	cmd.AddCommand(EnableSafeMigrationsCmd(ch))
@@ -27,7 +27,7 @@ func SafeMigrationsCmd(ch *cmdutil.Helper) *cobra.Command {
 func EnableSafeMigrationsCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "enable <database> <branch>",
-		Short: "Enable safe migrations for a branch",
+		Short: "Enable safe migrations for a MySQL branch",
 		Args:  cmdutil.RequiredArgs("database", "branch"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
@@ -98,7 +98,7 @@ func EnableSafeMigrationsCmd(ch *cmdutil.Helper) *cobra.Command {
 func DisableSafeMigrationsCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "disable <database> <branch>",
-		Short: "Disable safe migrations for a branch",
+		Short: "Disable safe migrations for a MySQL branch",
 		Args:  cmdutil.RequiredArgs("database", "branch"),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
diff --git a/internal/cmd/configprofile/changes.go b/internal/cmd/configprofile/changes.go
new file mode 100644
index 000000000..af9b2307c
--- /dev/null
+++ b/internal/cmd/configprofile/changes.go
@@ -0,0 +1,158 @@
+package configprofile
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ChangesCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "changes <command>",
+		Short: "Manage changes to a Neki configuration profile",
+	}
+	cmd.AddCommand(changesListCmd(ch), changesShowCmd(ch), changesCancelCmd(ch))
+	return cmd
+}
+
+func changesListCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		period      string
+		completedAt string
+		page        int
+		perPage     int
+	}
+
+	cmd := &cobra.Command{
+		Use:     "list <database> <branch> <name>",
+		Short:   "List changes for a Neki configuration profile",
+		Args:    cmdutil.ExactArgs("database", "branch", "name"),
+		Aliases: []string{"ls"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching changes for configuration profile %s", printer.BoldBlue(name)))
+			defer end()
+			changes, err := client.NekiShardConfigurationProfiles.ListChanges(cmd.Context(), &ps.ListNekiShardConfigurationProfileChangesRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: name,
+				Period:               flags.period,
+				CompletedAt:          flags.completedAt,
+				Page:                 flags.page,
+				PerPage:              flags.perPage,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+
+			if len(changes) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No changes found for configuration profile %s.\n", printer.BoldBlue(name))
+				return nil
+			}
+			return ch.Printer.PrintResource(toChanges(changes))
+		},
+	}
+
+	cmd.Flags().StringVar(&flags.period, "period", "", "Only show changes from this period")
+	cmd.Flags().StringVar(&flags.completedAt, "completed-at", "", "Only show changes completed at this time")
+	cmd.Flags().IntVar(&flags.page, "page", 0, "Page number to fetch")
+	cmd.Flags().IntVar(&flags.perPage, "per-page", 100, "Number of results per page")
+	return cmd
+}
+
+func changesShowCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:     "show <database> <branch> <name> <change-id>",
+		Short:   "Show a change to a Neki configuration profile",
+		Args:    cmdutil.ExactArgs("database", "branch", "name", "change-id"),
+		Aliases: []string{"get"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name, changeID := args[0], args[1], args[2], args[3]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching change %s", printer.BoldBlue(changeID)))
+			defer end()
+			change, err := client.NekiShardConfigurationProfiles.GetChange(cmd.Context(), &ps.GetNekiShardConfigurationProfileChangeRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: name,
+				Change:               changeID,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+			if ch.Printer.Format() == printer.Human {
+				if err := ch.Printer.PrintResource(toChange(change)); err != nil {
+					return err
+				}
+
+				differences := changeDifferences(change)
+				if len(differences) == 0 {
+					ch.Printer.Println("No configuration differences.")
+					return nil
+				}
+
+				ch.Printer.Println("Changes:")
+				for _, difference := range differences {
+					ch.Printer.Printf("  %s: %s → %s\n", difference.Field, difference.Before, difference.After)
+				}
+				return nil
+			}
+			return ch.Printer.PrintResource(toChange(change))
+		},
+	}
+}
+
+func changesCancelCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:   "cancel <database> <branch> <name> <change-id>",
+		Short: "Cancel a pending change to a Neki configuration profile",
+		Args:  cmdutil.ExactArgs("database", "branch", "name", "change-id"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name, changeID := args[0], args[1], args[2], args[3]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Cancelling change %s", printer.BoldBlue(changeID)))
+			defer end()
+			err = client.NekiShardConfigurationProfiles.CancelChange(cmd.Context(), &ps.CancelNekiShardConfigurationProfileChangeRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: name,
+				Change:               changeID,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Canceled change %s for configuration profile %s.\n", printer.BoldBlue(changeID), printer.BoldBlue(name))
+				return nil
+			}
+			return ch.Printer.PrintResource(map[string]string{
+				"result":                "change canceled",
+				"change_id":             changeID,
+				"configuration_profile": name,
+			})
+		},
+	}
+}
diff --git a/internal/cmd/configprofile/config_profile.go b/internal/cmd/configprofile/config_profile.go
new file mode 100644
index 000000000..f7d4f275d
--- /dev/null
+++ b/internal/cmd/configprofile/config_profile.go
@@ -0,0 +1,366 @@
+package configprofile
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/spf13/cobra"
+)
+
+func ConfigProfileCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "config-profile <command>",
+		Short: "Manage configuration profiles for a Neki database branch",
+		Long:  "Manage configuration profiles for a Neki database branch.\n\nThis command is only supported for Neki databases.",
+	}
+	cmd.AddCommand(
+		ChangesCmd(ch), CreateCmd(ch), DefaultCmd(ch), DeleteCmd(ch), ExtensionsCmd(ch),
+		ListCmd(ch), MaintenanceCmd(ch), ParametersCmd(ch), SetDefaultCmd(ch), ShowCmd(ch), UpdateCmd(ch),
+	)
+	return cmd
+}
+
+type profileDisplay struct {
+	Name            string `header:"name" json:"name"`
+	State           string `header:"state" json:"state"`
+	Default         bool   `header:"default" json:"default"`
+	Architecture    string `header:"architecture" json:"architecture"`
+	ClusterSize     string `header:"cluster size" json:"cluster_size"`
+	Replicas        int    `header:"replicas" json:"replicas"`
+	Shards          int    `header:"shards" json:"shards"`
+	PostgresVersion string `header:"postgres version" json:"postgres_version"`
+	MinStorage      string `header:"min storage" json:"min_storage"`
+	MaxStorage      string `header:"max storage" json:"max_storage"`
+	Autoscaling     string `header:"storage autoscaling" json:"storage_autoscaling"`
+	CreatedAt       string `header:"created at" json:"created_at"`
+	orig            *ps.NekiShardConfigurationProfile
+}
+
+func (p *profileDisplay) MarshalJSON() ([]byte, error) { return json.Marshal(p.orig) }
+func (p *profileDisplay) MarshalCSVValue() interface{} { return []*profileDisplay{p} }
+
+func toProfile(p *ps.NekiShardConfigurationProfile) *profileDisplay {
+	return &profileDisplay{
+		Name:            p.Name,
+		State:           p.State,
+		Default:         p.Default,
+		Architecture:    p.Architecture,
+		ClusterSize:     p.ClusterSize,
+		Replicas:        p.Replicas,
+		Shards:          p.Shards,
+		PostgresVersion: fmt.Sprintf("%d.%d", p.PostgresMajorVersion, p.PostgresMinorVersion),
+		MinStorage:      storageBytes(p.Storage, func(s *ps.NekiStorage) *int64 { return s.MinimumStorageBytes }),
+		MaxStorage:      storageBytes(p.Storage, func(s *ps.NekiStorage) *int64 { return s.MaximumStorageBytes }),
+		Autoscaling:     storageAutoscaling(p.Storage),
+		CreatedAt:       p.CreatedAt.UTC().Format("2006-01-02 15:04:05"),
+		orig:            p,
+	}
+}
+
+func toProfiles(profiles []*ps.NekiShardConfigurationProfile) []*profileDisplay {
+	out := make([]*profileDisplay, 0, len(profiles))
+	for _, profile := range profiles {
+		out = append(out, toProfile(profile))
+	}
+	return out
+}
+
+type parameterDisplay struct {
+	Namespace string `header:"namespace" json:"namespace"`
+	Name      string `header:"name" json:"name"`
+	Value     string `header:"value" json:"value"`
+	Default   string `header:"default" json:"default_value"`
+	Type      string `header:"type" json:"parameter_type"`
+	Restart   bool   `header:"restart" json:"restart"`
+	Required  bool   `header:"required" json:"required"`
+	orig      *ps.NekiParameter
+}
+
+func (p *parameterDisplay) MarshalJSON() ([]byte, error) { return json.Marshal(p.orig) }
+
+func formatValue(v interface{}) string {
+	switch value := v.(type) {
+	case nil:
+		return ""
+	case string:
+		return value
+	case float64:
+		return strconv.FormatFloat(value, 'f', -1, 64)
+	default:
+		return fmt.Sprintf("%v", value)
+	}
+}
+func toParameters(parameters []*ps.NekiParameter) []*parameterDisplay {
+	out := make([]*parameterDisplay, 0, len(parameters))
+	for _, p := range parameters {
+		out = append(out, &parameterDisplay{
+			Namespace: p.Namespace,
+			Name:      p.Name,
+			Value:     formatValue(p.Value),
+			Default:   formatValue(p.DefaultValue),
+			Type:      p.ParameterType,
+			Restart:   p.Restart,
+			Required:  p.Required,
+			orig:      p,
+		})
+	}
+	return out
+}
+
+type extensionDisplay struct {
+	Name       string `header:"name" json:"name"`
+	Enabled    bool   `header:"enabled" json:"enabled"`
+	Internal   bool   `header:"internal" json:"internal"`
+	Loader     string `header:"loader" json:"loader"`
+	Parameters int    `header:"parameters" json:"parameters"`
+	orig       *ps.NekiExtension
+}
+
+func (e *extensionDisplay) MarshalJSON() ([]byte, error) { return json.Marshal(e.orig) }
+
+func toExtension(e *ps.NekiExtension) *extensionDisplay {
+	return &extensionDisplay{
+		Name:       e.Name,
+		Enabled:    e.Enabled,
+		Internal:   e.Internal,
+		Loader:     e.Loader,
+		Parameters: len(e.Parameters),
+		orig:       e,
+	}
+}
+
+func toExtensions(extensions []*ps.NekiExtension) []*extensionDisplay {
+	out := make([]*extensionDisplay, 0, len(extensions))
+	for _, e := range extensions {
+		out = append(out, toExtension(e))
+	}
+	return out
+}
+
+type changeDisplay struct {
+	ID          string `header:"id" json:"id"`
+	State       string `header:"state" json:"state"`
+	Name        string `header:"name" json:"name"`
+	ClusterSize string `header:"cluster size" json:"cluster_size"`
+	Replicas    int    `header:"replicas" json:"replicas"`
+	CreatedAt   string `header:"created at" json:"created_at"`
+	orig        *ps.NekiShardConfigurationProfileChange
+}
+
+func (c *changeDisplay) MarshalJSON() ([]byte, error) { return json.Marshal(c.orig) }
+func (c *changeDisplay) MarshalCSVValue() interface{} { return []*changeDisplay{c} }
+
+func toChange(c *ps.NekiShardConfigurationProfileChange) *changeDisplay {
+	return &changeDisplay{
+		ID:          c.ID,
+		State:       c.State,
+		Name:        c.Name,
+		ClusterSize: c.ClusterSize,
+		Replicas:    c.Replicas,
+		CreatedAt:   c.CreatedAt.UTC().Format("2006-01-02 15:04:05"),
+		orig:        c,
+	}
+}
+
+func toChanges(changes []*ps.NekiShardConfigurationProfileChange) []*changeDisplay {
+	out := make([]*changeDisplay, 0, len(changes))
+	for _, change := range changes {
+		out = append(out, toChange(change))
+	}
+	return out
+}
+
+type changeDifference struct {
+	Field  string
+	Before string
+	After  string
+}
+
+func changeDifferences(change *ps.NekiShardConfigurationProfileChange) []changeDifference {
+	differences := make([]changeDifference, 0)
+	if change.PreviousName != change.Name {
+		differences = append(differences, changeDifference{Field: "Name", Before: change.PreviousName, After: change.Name})
+	}
+	if change.PreviousClusterSize != change.ClusterSize {
+		differences = append(differences, changeDifference{Field: "Cluster size", Before: change.PreviousClusterSize, After: change.ClusterSize})
+	}
+	if change.PreviousReplicas != change.Replicas {
+		differences = append(differences, changeDifference{
+			Field:  "Replicas",
+			Before: strconv.Itoa(change.PreviousReplicas),
+			After:  strconv.Itoa(change.Replicas),
+		})
+	}
+	differences = appendStorageDifferences(differences, change.PreviousStorage, change.Storage)
+
+	parameterKeys := make(map[string]struct{})
+	for namespace, parameters := range change.PreviousParameters {
+		for name := range parameters {
+			parameterKeys[namespace+"."+name] = struct{}{}
+		}
+	}
+	for namespace, parameters := range change.Parameters {
+		for name := range parameters {
+			parameterKeys[namespace+"."+name] = struct{}{}
+		}
+	}
+
+	keys := make([]string, 0, len(parameterKeys))
+	for key := range parameterKeys {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		namespace, name, _ := strings.Cut(key, ".")
+		before, hadBefore := change.PreviousParameters[namespace][name]
+		after, hasAfter := change.Parameters[namespace][name]
+		if hadBefore && hasAfter && before == after {
+			continue
+		}
+		if !hadBefore {
+			before = "(default)"
+		}
+		if !hasAfter {
+			after = "(default)"
+		}
+		differences = append(differences, changeDifference{Field: "Parameter " + key, Before: before, After: after})
+	}
+
+	return differences
+}
+
+func stringPointerIfChanged(cmd *cobra.Command, name, value string) *string {
+	if !cmd.Flags().Changed(name) {
+		return nil
+	}
+	return &value
+}
+func intPointerIfChanged(cmd *cobra.Command, name string, value int) *int {
+	if !cmd.Flags().Changed(name) {
+		return nil
+	}
+	return &value
+}
+
+func int64PointerIfChanged(cmd *cobra.Command, name string, value int64) *int64 {
+	if !cmd.Flags().Changed(name) {
+		return nil
+	}
+	return &value
+}
+
+func boolPointerIfChanged(cmd *cobra.Command, name string, value bool) *bool {
+	if !cmd.Flags().Changed(name) {
+		return nil
+	}
+	return &value
+}
+
+type storageFlags struct {
+	minStorage, maxStorage, iops, throughput int64
+	autoscaling                              bool
+}
+
+func bindStorageFlags(cmd *cobra.Command, flags *storageFlags) {
+	cmd.Flags().Int64Var(&flags.minStorage, "min-storage", 0, "Minimum storage size in bytes")
+	cmd.Flags().Int64Var(&flags.maxStorage, "max-storage", 0, "Maximum storage size in bytes for autoscaling")
+	cmd.Flags().BoolVar(&flags.autoscaling, "storage-autoscaling", false, "Enable storage autoscaling")
+	cmd.Flags().Int64Var(&flags.iops, "storage-iops", 0, "Storage IOPS")
+	cmd.Flags().Int64Var(&flags.throughput, "storage-throughput", 0, "Storage throughput in MiB/s")
+}
+
+func storageFromFlags(cmd *cobra.Command, flags storageFlags) *ps.NekiStorage {
+	storage := &ps.NekiStorage{
+		MinimumStorageBytes:   int64PointerIfChanged(cmd, "min-storage", flags.minStorage),
+		MaximumStorageBytes:   int64PointerIfChanged(cmd, "max-storage", flags.maxStorage),
+		StorageAutoscaling:    boolPointerIfChanged(cmd, "storage-autoscaling", flags.autoscaling),
+		StorageIOPS:           int64PointerIfChanged(cmd, "storage-iops", flags.iops),
+		StorageThroughputMiBs: int64PointerIfChanged(cmd, "storage-throughput", flags.throughput),
+	}
+	if storage.MinimumStorageBytes == nil && storage.MaximumStorageBytes == nil && storage.StorageAutoscaling == nil && storage.StorageIOPS == nil && storage.StorageThroughputMiBs == nil {
+		return nil
+	}
+	return storage
+}
+
+func storageFlagChanged(cmd *cobra.Command) bool {
+	for _, name := range []string{"min-storage", "max-storage", "storage-autoscaling", "storage-iops", "storage-throughput"} {
+		if cmd.Flags().Changed(name) {
+			return true
+		}
+	}
+	return false
+}
+
+func storageBytes(storage *ps.NekiStorage, value func(*ps.NekiStorage) *int64) string {
+	if storage == nil {
+		return ""
+	}
+	return formatOptionalInt64(value(storage))
+}
+
+func storageAutoscaling(storage *ps.NekiStorage) string {
+	if storage == nil || storage.StorageAutoscaling == nil {
+		return ""
+	}
+	if *storage.StorageAutoscaling {
+		return "Yes"
+	}
+	return "No"
+}
+
+func formatOptionalInt64(value *int64) string {
+	if value == nil {
+		return ""
+	}
+	return strconv.FormatInt(*value, 10)
+}
+
+func formatOptionalBool(value *bool) string {
+	if value == nil {
+		return ""
+	}
+	if *value {
+		return "true"
+	}
+	return "false"
+}
+
+func appendStorageDifferences(differences []changeDifference, before, after *ps.NekiStorage) []changeDifference {
+	pairs := []struct {
+		field  string
+		before string
+		after  string
+	}{
+		{"Min storage", storageBytes(before, func(s *ps.NekiStorage) *int64 { return s.MinimumStorageBytes }), storageBytes(after, func(s *ps.NekiStorage) *int64 { return s.MinimumStorageBytes })},
+		{"Max storage", storageBytes(before, func(s *ps.NekiStorage) *int64 { return s.MaximumStorageBytes }), storageBytes(after, func(s *ps.NekiStorage) *int64 { return s.MaximumStorageBytes })},
+		{"Storage autoscaling", formatOptionalBool(storageAutoscalingPtr(before)), formatOptionalBool(storageAutoscalingPtr(after))},
+		{"Storage IOPS", storageBytes(before, func(s *ps.NekiStorage) *int64 { return s.StorageIOPS }), storageBytes(after, func(s *ps.NekiStorage) *int64 { return s.StorageIOPS })},
+		{"Storage throughput", storageBytes(before, func(s *ps.NekiStorage) *int64 { return s.StorageThroughputMiBs }), storageBytes(after, func(s *ps.NekiStorage) *int64 { return s.StorageThroughputMiBs })},
+	}
+	for _, pair := range pairs {
+		if pair.before == pair.after {
+			continue
+		}
+		if pair.before == "" {
+			pair.before = "(default)"
+		}
+		if pair.after == "" {
+			pair.after = "(default)"
+		}
+		differences = append(differences, changeDifference{Field: pair.field, Before: pair.before, After: pair.after})
+	}
+	return differences
+}
+
+func storageAutoscalingPtr(storage *ps.NekiStorage) *bool {
+	if storage == nil {
+		return nil
+	}
+	return storage.StorageAutoscaling
+}
diff --git a/internal/cmd/configprofile/config_profile_test.go b/internal/cmd/configprofile/config_profile_test.go
new file mode 100644
index 000000000..f7aa01cc7
--- /dev/null
+++ b/internal/cmd/configprofile/config_profile_test.go
@@ -0,0 +1,465 @@
+package configprofile
+
+import (
+	"bytes"
+	"context"
+	"testing"
+	"time"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/config"
+	"github.com/planetscale/cli/internal/mock"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+func configProfileTestHelper(svc ps.NekiShardConfigurationProfilesService, out *bytes.Buffer) *cmdutil.Helper {
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(out)
+	return &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiShardConfigurationProfiles: svc}, nil
+		},
+	}
+}
+
+func testProfile() *ps.NekiShardConfigurationProfile {
+	return &ps.NekiShardConfigurationProfile{
+		Name:                 "metal",
+		Architecture:         "arm64",
+		ClusterSize:          "M1-10",
+		ClusterDisplayName:   "Metal 10",
+		Default:              true,
+		Metal:                true,
+		Replicas:             2,
+		PostgresMajorVersion: 17,
+		PostgresMinorVersion: 6,
+		Shards:               3,
+		State:                "ready",
+		CreatedAt:            time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+		UpdatedAt:            time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+	}
+}
+
+func TestConfigProfileListCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{
+		ListFn: func(_ context.Context, req *ps.ListNekiShardConfigurationProfilesRequest) ([]*ps.NekiShardConfigurationProfile, error) {
+			c.Assert(req, qt.DeepEquals, &ps.ListNekiShardConfigurationProfilesRequest{Organization: "acme", Database: "app", Branch: "main"})
+			return []*ps.NekiShardConfigurationProfile{testProfile()}, nil
+		},
+	}
+
+	cmd := ListCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.ListFnInvoked, qt.IsTrue)
+	c.Assert(out.String(), qt.JSONEquals, []map[string]interface{}{{
+		"name":                   "metal",
+		"architecture":           "arm64",
+		"cluster_size":           "M1-10",
+		"cluster_display_name":   "Metal 10",
+		"default":                true,
+		"metal":                  true,
+		"replicas":               2,
+		"postgres_major_version": 17,
+		"postgres_minor_version": 6,
+		"shards":                 3,
+		"state":                  "ready",
+		"created_at":             "2026-08-04T12:00:00Z",
+		"updated_at":             "2026-08-04T12:00:00Z",
+	}})
+}
+
+func TestConfigProfileListHumanHeadersAndUTC(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	profile := testProfile()
+	profile.CreatedAt = time.Date(2026, 8, 4, 12, 0, 0, 0, time.FixedZone("MDT", -6*60*60))
+	svc := &mock.NekiShardConfigurationProfilesService{ListFn: func(context.Context, *ps.ListNekiShardConfigurationProfilesRequest) ([]*ps.NekiShardConfigurationProfile, error) {
+		return []*ps.NekiShardConfigurationProfile{profile}, nil
+	}}
+	ch := &cmdutil.Helper{Printer: p, Config: &config.Config{Organization: "acme"}, Client: func() (*ps.Client, error) {
+		return &ps.Client{NekiShardConfigurationProfiles: svc}, nil
+	}}
+
+	cmd := ListCmd(ch)
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "CLUSTER SIZE")
+	c.Assert(out.String(), qt.Contains, "POSTGRES VERSION")
+	c.Assert(out.String(), qt.Contains, "MIN STORAGE")
+	c.Assert(out.String(), qt.Contains, "MAX STORAGE")
+	c.Assert(out.String(), qt.Contains, "STORAGE AUTOSCALING")
+	c.Assert(out.String(), qt.Contains, "CREATED AT")
+	c.Assert(out.String(), qt.Contains, "2026-08-04 18:00:00")
+}
+
+func TestConfigProfileCreateCmdOnlySendsChangedOptionalFlags(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{CreateFn: func(_ context.Context, req *ps.CreateNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+		c.Assert(req.Organization, qt.Equals, "acme")
+		c.Assert(req.Database, qt.Equals, "app")
+		c.Assert(req.Branch, qt.Equals, "main")
+		c.Assert(req.Name, qt.Equals, "metal")
+		c.Assert(req.ClusterSize, qt.IsNil)
+		c.Assert(req.Replicas, qt.IsNotNil)
+		c.Assert(*req.Replicas, qt.Equals, 0)
+		c.Assert(req.PostgresMajorVersion, qt.IsNil)
+		c.Assert(req.PostgresMinorVersion, qt.IsNil)
+		return testProfile(), nil
+	}}
+
+	cmd := CreateCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "--replicas", "0"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.CreateFnInvoked, qt.IsTrue)
+}
+
+func TestConfigProfileCreateCmdSendsStorage(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{CreateFn: func(_ context.Context, req *ps.CreateNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+		c.Assert(req.Storage, qt.DeepEquals, &ps.NekiStorage{
+			MinimumStorageBytes:   int64Ptr(10737418240),
+			MaximumStorageBytes:   int64Ptr(107374182400),
+			StorageAutoscaling:    boolPtr(true),
+			StorageIOPS:           int64Ptr(4000),
+			StorageThroughputMiBs: int64Ptr(250),
+		})
+		return testProfile(), nil
+	}}
+
+	cmd := CreateCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "--min-storage", "10737418240", "--max-storage", "107374182400", "--storage-autoscaling", "--storage-iops", "4000", "--storage-throughput", "250"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.CreateFnInvoked, qt.IsTrue)
+}
+
+func TestConfigProfileCreateCmdRejectsExtraArguments(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{}
+
+	cmd := CreateCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "extra"})
+
+	c.Assert(cmd.Execute(), qt.ErrorMatches, `accepts 3 arg\(s\), received 4`)
+	c.Assert(svc.CreateFnInvoked, qt.IsFalse)
+}
+
+func TestConfigProfileUpdateCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{UpdateFn: func(_ context.Context, req *ps.UpdateNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+		c.Assert(req.Organization, qt.Equals, "acme")
+		c.Assert(req.Database, qt.Equals, "app")
+		c.Assert(req.Branch, qt.Equals, "main")
+		c.Assert(req.ConfigurationProfile, qt.Equals, "metal")
+		c.Assert(req.Name, qt.IsNil)
+		c.Assert(req.Replicas, qt.IsNotNil)
+		c.Assert(*req.Replicas, qt.Equals, 2)
+		c.Assert(req.Parameters, qt.DeepEquals, map[string]map[string]string{
+			"pgconf":    {"max_connections": "200", "work_mem": "64MB"},
+			"pgbouncer": {"default_pool_size": "20"},
+		})
+		return testProfile(), nil
+	}}
+
+	cmd := UpdateCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "--replicas", "2", "--parameters", "pgconf.max_connections=200", "--parameters", "pgconf.work_mem=64MB", "--parameters", "pgbouncer.default_pool_size=20"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.UpdateFnInvoked, qt.IsTrue)
+}
+
+func TestConfigProfileUpdateCmdSendsStorage(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{UpdateFn: func(_ context.Context, req *ps.UpdateNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+		c.Assert(req.Storage, qt.DeepEquals, &ps.NekiStorage{
+			MinimumStorageBytes: int64Ptr(21474836480),
+			StorageAutoscaling:  boolPtr(false),
+		})
+		c.Assert(req.Replicas, qt.IsNil)
+		return testProfile(), nil
+	}}
+
+	cmd := UpdateCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "--min-storage", "21474836480", "--storage-autoscaling=false"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.UpdateFnInvoked, qt.IsTrue)
+}
+
+func TestConfigProfileDefaultCommands(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{
+		GetDefaultFn: func(_ context.Context, req *ps.GetDefaultNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+			c.Assert(req, qt.DeepEquals, &ps.GetDefaultNekiShardConfigurationProfileRequest{Organization: "acme", Database: "app", Branch: "main"})
+			return testProfile(), nil
+		},
+		SetDefaultFn: func(_ context.Context, req *ps.SetDefaultNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+			c.Assert(req, qt.DeepEquals, &ps.SetDefaultNekiShardConfigurationProfileRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal"})
+			return testProfile(), nil
+		},
+	}
+
+	ch := configProfileTestHelper(svc, &out)
+	cmd := DefaultCmd(ch)
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.GetDefaultFnInvoked, qt.IsTrue)
+
+	out.Reset()
+	cmd = SetDefaultCmd(ch)
+	cmd.SetArgs([]string{"app", "main", "metal"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.SetDefaultFnInvoked, qt.IsTrue)
+}
+
+func TestConfigProfileParametersCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{ListParametersFn: func(_ context.Context, req *ps.ListNekiShardConfigurationProfileParametersRequest) ([]*ps.NekiParameter, error) {
+		c.Assert(req.Extension, qt.IsNotNil)
+		c.Assert(*req.Extension, qt.IsTrue)
+		c.Assert(req.Internal, qt.IsNil)
+		return []*ps.NekiParameter{
+			{Name: "work_mem", Namespace: "pgconf", Value: "64MB"},
+			{Name: "default_pool_size", Namespace: "pgbouncer", Value: "20"},
+		}, nil
+	}}
+
+	cmd := ParametersCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "--namespace", "pgconf", "--extension"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, []map[string]interface{}{{
+		"name": "work_mem", "display_name": "", "namespace": "pgconf", "advanced": false,
+		"category": nil, "description": "", "parameter_type": "", "default_value": nil, "value": "64MB",
+		"required": false, "created_at": "0001-01-01T00:00:00Z", "updated_at": nil, "restart": false, "url": "",
+	}})
+}
+
+func TestConfigProfileChangesCancelCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{CancelChangeFn: func(_ context.Context, req *ps.CancelNekiShardConfigurationProfileChangeRequest) error {
+		c.Assert(req, qt.DeepEquals, &ps.CancelNekiShardConfigurationProfileChangeRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal", Change: "change-1"})
+		return nil
+	}}
+
+	cmd := changesCancelCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "change-1"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"result": "change canceled", "change_id": "change-1", "configuration_profile": "metal",
+	})
+}
+
+func TestConfigProfileChangesShowHumanDisplaysDifferences(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	svc := &mock.NekiShardConfigurationProfilesService{GetChangeFn: func(_ context.Context, req *ps.GetNekiShardConfigurationProfileChangeRequest) (*ps.NekiShardConfigurationProfileChange, error) {
+		c.Assert(req, qt.DeepEquals, &ps.GetNekiShardConfigurationProfileChangeRequest{
+			Organization:         "acme",
+			Database:             "app",
+			Branch:               "main",
+			ConfigurationProfile: "metal",
+			Change:               "change-1",
+		})
+		return &ps.NekiShardConfigurationProfileChange{
+			ID:                  "change-1",
+			State:               "applying",
+			Name:                "metal-next",
+			PreviousName:        "metal",
+			ClusterSize:         "M1-20",
+			PreviousClusterSize: "M1-10",
+			Replicas:            3,
+			PreviousReplicas:    2,
+			Storage: &ps.NekiStorage{
+				MinimumStorageBytes: int64Ptr(21474836480),
+				StorageAutoscaling:  boolPtr(false),
+			},
+			PreviousStorage: &ps.NekiStorage{
+				MinimumStorageBytes: int64Ptr(10737418240),
+				StorageAutoscaling:  boolPtr(true),
+			},
+			CreatedAt: time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+			Parameters: map[string]map[string]string{"pgconf": {
+				"log_rotation_size": "100MB",
+				"max_connections":   "200",
+				"work_mem":          "64MB",
+			}},
+			PreviousParameters: map[string]map[string]string{"pgconf": {
+				"max_connections":   "100",
+				"statement_timeout": "10s",
+				"work_mem":          "64MB",
+			}},
+		}, nil
+	}}
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiShardConfigurationProfiles: svc}, nil
+		},
+	}
+
+	cmd := changesShowCmd(ch)
+	cmd.SetArgs([]string{"app", "main", "metal", "change-1"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "Changes:")
+	c.Assert(out.String(), qt.Contains, "Name: metal → metal-next")
+	c.Assert(out.String(), qt.Contains, "Cluster size: M1-10 → M1-20")
+	c.Assert(out.String(), qt.Contains, "Replicas: 2 → 3")
+	c.Assert(out.String(), qt.Contains, "Min storage: 10737418240 → 21474836480")
+	c.Assert(out.String(), qt.Contains, "Storage autoscaling: true → false")
+	c.Assert(out.String(), qt.Contains, "Parameter pgconf.log_rotation_size: (default) → 100MB")
+	c.Assert(out.String(), qt.Contains, "Parameter pgconf.max_connections: 100 → 200")
+	c.Assert(out.String(), qt.Contains, "Parameter pgconf.statement_timeout: 10s → (default)")
+}
+
+func TestConfigProfileMaintenanceCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{RunMaintenanceFn: func(_ context.Context, req *ps.RunNekiShardConfigurationProfileMaintenanceRequest) error {
+		c.Assert(req, qt.DeepEquals, &ps.RunNekiShardConfigurationProfileMaintenanceRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal"})
+		return nil
+	}}
+
+	cmd := MaintenanceCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.RunMaintenanceFnInvoked, qt.IsTrue)
+	c.Assert(svc.RunBulkMaintenanceFnInvoked, qt.IsFalse)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"result":                 "maintenance started",
+		"configuration_profiles": []interface{}{"metal"},
+	})
+}
+
+func TestConfigProfileMaintenanceCmdBulk(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{RunBulkMaintenanceFn: func(_ context.Context, req *ps.RunNekiShardConfigurationProfilesMaintenanceRequest) error {
+		c.Assert(req, qt.DeepEquals, &ps.RunNekiShardConfigurationProfilesMaintenanceRequest{
+			Organization:              "acme",
+			Database:                  "app",
+			Branch:                    "main",
+			ConfigurationProfileNames: []string{"metal", "analytics"},
+		})
+		return nil
+	}}
+
+	cmd := MaintenanceCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "analytics"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.RunBulkMaintenanceFnInvoked, qt.IsTrue)
+	c.Assert(svc.RunMaintenanceFnInvoked, qt.IsFalse)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"result":                 "maintenance started",
+		"configuration_profiles": []interface{}{"metal", "analytics"},
+	})
+}
+
+func TestConfigProfileExtensionsEnableCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{UpdateExtensionFn: func(_ context.Context, req *ps.UpdateNekiShardConfigurationProfileExtensionRequest) (*ps.NekiExtension, error) {
+		c.Assert(req, qt.DeepEquals, &ps.UpdateNekiShardConfigurationProfileExtensionRequest{
+			Organization:         "acme",
+			Database:             "app",
+			Branch:               "main",
+			ConfigurationProfile: "metal",
+			Extension:            "pg_stat_statements",
+			Enabled:              true,
+		})
+		return &ps.NekiExtension{Name: "pg_stat_statements", Enabled: true, Loader: "shared_preload_libraries"}, nil
+	}}
+
+	cmd := ExtensionsCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"enable", "app", "main", "metal", "pg_stat_statements"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.UpdateExtensionFnInvoked, qt.IsTrue)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"name":        "pg_stat_statements",
+		"description": "",
+		"enabled":     true,
+		"internal":    false,
+		"loader":      "shared_preload_libraries",
+		"url":         "",
+		"parameters":  nil,
+	})
+}
+
+func TestConfigProfileExtensionsDisableCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{UpdateExtensionFn: func(_ context.Context, req *ps.UpdateNekiShardConfigurationProfileExtensionRequest) (*ps.NekiExtension, error) {
+		c.Assert(req.Enabled, qt.IsFalse)
+		return &ps.NekiExtension{Name: req.Extension, Enabled: false}, nil
+	}}
+
+	cmd := ExtensionsCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"disable", "app", "main", "metal", "vector"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.UpdateExtensionFnInvoked, qt.IsTrue)
+}
+
+func TestConfigProfileDeleteCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardConfigurationProfilesService{DeleteFn: func(_ context.Context, req *ps.DeleteNekiShardConfigurationProfileRequest) error {
+		c.Assert(req, qt.DeepEquals, &ps.DeleteNekiShardConfigurationProfileRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal"})
+		return nil
+	}}
+
+	cmd := DeleteCmd(configProfileTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "--force"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"result": "configuration profile deleted", "configuration_profile": "metal", "branch": "main",
+	})
+}
+
+func TestConfigProfileCmdSubcommands(t *testing.T) {
+	cmd := ConfigProfileCmd(&cmdutil.Helper{Config: &config.Config{}})
+	for _, name := range []string{"changes", "create", "default", "delete", "extensions", "list", "maintenance", "parameters", "set-default", "show", "update"} {
+		found, _, err := cmd.Find([]string{name})
+		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, found.Name(), qt.Equals, name)
+	}
+
+	changes, _, err := cmd.Find([]string{"changes"})
+	qt.Assert(t, err, qt.IsNil)
+	for _, name := range []string{"cancel", "list", "show"} {
+		found, _, err := changes.Find([]string{name})
+		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, found.Name(), qt.Equals, name)
+	}
+
+	extensions, _, err := cmd.Find([]string{"extensions"})
+	qt.Assert(t, err, qt.IsNil)
+	for _, name := range []string{"disable", "enable"} {
+		found, _, err := extensions.Find([]string{name})
+		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, found.Name(), qt.Equals, name)
+	}
+}
+
+func int64Ptr(v int64) *int64 { return &v }
+func boolPtr(v bool) *bool    { return &v }
diff --git a/internal/cmd/configprofile/create.go b/internal/cmd/configprofile/create.go
new file mode 100644
index 000000000..487d230e6
--- /dev/null
+++ b/internal/cmd/configprofile/create.go
@@ -0,0 +1,64 @@
+package configprofile
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		clusterSize  string
+		replicas     int
+		major, minor string
+		storage      storageFlags
+	}
+	cmd := &cobra.Command{
+		Use:   "create <database> <branch> <name>",
+		Short: "Create a Neki configuration profile",
+		Args:  cmdutil.ExactArgs("database", "branch", "name"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name := args[0], args[1], args[2]
+			if cmd.Flags().Changed("postgres-minor-version") && !cmd.Flags().Changed("postgres-major-version") {
+				return fmt.Errorf("--postgres-major-version is required with --postgres-minor-version")
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Creating configuration profile %s", printer.BoldBlue(name)))
+			defer end()
+			profile, err := client.NekiShardConfigurationProfiles.Create(cmd.Context(), &ps.CreateNekiShardConfigurationProfileRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				Name:                 name,
+				ClusterSize:          stringPointerIfChanged(cmd, "cluster-size", flags.clusterSize),
+				Replicas:             intPointerIfChanged(cmd, "replicas", flags.replicas),
+				PostgresMajorVersion: stringPointerIfChanged(cmd, "postgres-major-version", flags.major),
+				PostgresMinorVersion: stringPointerIfChanged(cmd, "postgres-minor-version", flags.minor),
+				Storage:              storageFromFlags(cmd, flags.storage),
+			})
+			if err != nil {
+				return handleError(err, database, branch, "")
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Configuration profile %s was successfully created.\n", printer.BoldBlue(profile.Name))
+			}
+			return ch.Printer.PrintResource(toProfile(profile))
+		},
+	}
+	cmd.Flags().StringVar(&flags.clusterSize, "cluster-size", "", "Cluster size for shards in the profile")
+	cmd.Flags().IntVar(&flags.replicas, "replicas", 0, "Number of replicas for shards in the profile")
+	cmd.Flags().StringVar(&flags.major, "postgres-major-version", "", "PostgreSQL major version")
+	cmd.Flags().StringVar(&flags.minor, "postgres-minor-version", "", "PostgreSQL minor version")
+	bindStorageFlags(cmd, &flags.storage)
+	return cmd
+}
diff --git a/internal/cmd/configprofile/default.go b/internal/cmd/configprofile/default.go
new file mode 100644
index 000000000..2eb074738
--- /dev/null
+++ b/internal/cmd/configprofile/default.go
@@ -0,0 +1,38 @@
+package configprofile
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func DefaultCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:   "default <database> <branch>",
+		Short: "Show the default Neki configuration profile",
+		Args:  cmdutil.ExactArgs("database", "branch"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching the default configuration profile for %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+			profile, err := client.NekiShardConfigurationProfiles.GetDefault(cmd.Context(), &ps.GetDefaultNekiShardConfigurationProfileRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return handleError(err, database, branch, "")
+			}
+			end()
+			return ch.Printer.PrintResource(toProfile(profile))
+		},
+	}
+}
diff --git a/internal/cmd/configprofile/delete.go b/internal/cmd/configprofile/delete.go
new file mode 100644
index 000000000..3104829b8
--- /dev/null
+++ b/internal/cmd/configprofile/delete.go
@@ -0,0 +1,62 @@
+package configprofile
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func DeleteCmd(ch *cmdutil.Helper) *cobra.Command {
+	var force bool
+
+	cmd := &cobra.Command{
+		Use:     "delete <database> <branch> <name>",
+		Short:   "Delete a Neki configuration profile",
+		Args:    cmdutil.ExactArgs("database", "branch", "name"),
+		Aliases: []string{"rm"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name := args[0], args[1], args[2]
+			if !force {
+				confirmationName := fmt.Sprintf("%s/%s/%s", database, branch, name)
+				if err := ch.Printer.ConfirmCommand(confirmationName, "delete configuration profile", "deletion of configuration profile"); err != nil {
+					return err
+				}
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Deleting configuration profile %s", printer.BoldBlue(name)))
+			defer end()
+			err = client.NekiShardConfigurationProfiles.Delete(cmd.Context(), &ps.DeleteNekiShardConfigurationProfileRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: name,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Configuration profile %s was successfully deleted from %s/%s.\n", printer.BoldBlue(name), printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(map[string]string{
+				"result":                "configuration profile deleted",
+				"configuration_profile": name,
+				"branch":                branch,
+			})
+		},
+	}
+
+	cmd.Flags().BoolVar(&force, "force", false, "Delete the configuration profile without confirmation")
+	return cmd
+}
diff --git a/internal/cmd/configprofile/errors.go b/internal/cmd/configprofile/errors.go
new file mode 100644
index 000000000..67d6927ed
--- /dev/null
+++ b/internal/cmd/configprofile/errors.go
@@ -0,0 +1,19 @@
+package configprofile
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+func handleError(err error, database, branch, profile string) error {
+	if cmdutil.ErrCode(err) != ps.ErrNotFound {
+		return cmdutil.HandleError(err)
+	}
+	if profile != "" {
+		return fmt.Errorf("configuration profile %s does not exist in branch %s of database %s, or the branch is not a Neki branch", printer.BoldBlue(profile), printer.BoldBlue(branch), printer.BoldBlue(database))
+	}
+	return fmt.Errorf("database %s or branch %s does not exist, or the branch is not a Neki branch", printer.BoldBlue(database), printer.BoldBlue(branch))
+}
diff --git a/internal/cmd/configprofile/extensions.go b/internal/cmd/configprofile/extensions.go
new file mode 100644
index 000000000..aa020fc0a
--- /dev/null
+++ b/internal/cmd/configprofile/extensions.go
@@ -0,0 +1,95 @@
+package configprofile
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ExtensionsCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "extensions <database> <branch> <name>",
+		Short: "List extensions for a Neki configuration profile",
+		Args:  cmdutil.ExactArgs("database", "branch", "name"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching extensions for configuration profile %s", printer.BoldBlue(name)))
+			defer end()
+			extensions, err := client.NekiShardConfigurationProfiles.ListExtensions(cmd.Context(), &ps.ListNekiShardConfigurationProfileExtensionsRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: name,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+
+			if len(extensions) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No extensions found for configuration profile %s.\n", printer.BoldBlue(name))
+				return nil
+			}
+			return ch.Printer.PrintResource(toExtensions(extensions))
+		},
+	}
+
+	cmd.AddCommand(extensionsEnableCmd(ch), extensionsDisableCmd(ch))
+	return cmd
+}
+
+func extensionsEnableCmd(ch *cmdutil.Helper) *cobra.Command {
+	return extensionsToggleCmd(ch, "enable", "Enable an extension for a Neki configuration profile", true)
+}
+
+func extensionsDisableCmd(ch *cmdutil.Helper) *cobra.Command {
+	return extensionsToggleCmd(ch, "disable", "Disable an extension for a Neki configuration profile", false)
+}
+
+func extensionsToggleCmd(ch *cmdutil.Helper, use, short string, enabled bool) *cobra.Command {
+	action := "Enabling"
+	if !enabled {
+		action = "Disabling"
+	}
+
+	return &cobra.Command{
+		Use:   use + " <database> <branch> <name> <extension>",
+		Short: short,
+		Args:  cmdutil.ExactArgs("database", "branch", "name", "extension"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name, extensionName := args[0], args[1], args[2], args[3]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("%s extension %s", action, printer.BoldBlue(extensionName)))
+			defer end()
+			extension, err := client.NekiShardConfigurationProfiles.UpdateExtension(cmd.Context(), &ps.UpdateNekiShardConfigurationProfileExtensionRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: name,
+				Extension:            extensionName,
+				Enabled:              enabled,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Extension %s on configuration profile %s was %sd.\n", printer.BoldBlue(extension.Name), printer.BoldBlue(name), use)
+			}
+			return ch.Printer.PrintResource(toExtension(extension))
+		},
+	}
+}
diff --git a/internal/cmd/configprofile/list.go b/internal/cmd/configprofile/list.go
new file mode 100644
index 000000000..a01497859
--- /dev/null
+++ b/internal/cmd/configprofile/list.go
@@ -0,0 +1,44 @@
+package configprofile
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ListCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:     "list <database> <branch>",
+		Aliases: []string{"ls"},
+		Short:   "List configuration profiles for a Neki branch",
+		Args:    cmdutil.ExactArgs("database", "branch"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching configuration profiles for %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+			profiles, err := client.NekiShardConfigurationProfiles.List(cmd.Context(), &ps.ListNekiShardConfigurationProfilesRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return handleError(err, database, branch, "")
+			}
+			end()
+
+			if len(profiles) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No configuration profiles found in %s/%s.\n", printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+			return ch.Printer.PrintResource(toProfiles(profiles))
+		},
+	}
+}
diff --git a/internal/cmd/configprofile/maintenance.go b/internal/cmd/configprofile/maintenance.go
new file mode 100644
index 000000000..8cb6722e8
--- /dev/null
+++ b/internal/cmd/configprofile/maintenance.go
@@ -0,0 +1,80 @@
+package configprofile
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func MaintenanceCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:   "maintenance <database> <branch> <name>...",
+		Short: "Run maintenance for one or more Neki configuration profiles",
+		Long: `Run maintenance for one or more Neki configuration profiles, updating them
+to the latest available image.
+
+The upgrade is applied to the replicas first, followed by a switchover from the
+old primary to an upgraded replica. That failover leads to a short period of
+database unavailability (seconds), and all direct connections to those shards
+are terminated.
+
+Use 'pscale branch maintenance run' to maintain every profile on the branch.`,
+		Args: cmdutil.RequiredArgs("database", "branch", "name"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, profiles := args[0], args[1], args[2:]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			label := strings.Join(profiles, ", ")
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Starting maintenance for configuration profile %s", printer.BoldBlue(label)))
+			if len(profiles) > 1 {
+				end = ch.Printer.PrintProgress(fmt.Sprintf("Starting maintenance for configuration profiles %s", printer.BoldBlue(label)))
+			}
+			defer end()
+
+			if len(profiles) == 1 {
+				err = client.NekiShardConfigurationProfiles.RunMaintenance(cmd.Context(), &ps.RunNekiShardConfigurationProfileMaintenanceRequest{
+					Organization:         ch.Config.Organization,
+					Database:             database,
+					Branch:               branch,
+					ConfigurationProfile: profiles[0],
+				})
+			} else {
+				err = client.NekiShardConfigurationProfiles.RunBulkMaintenance(cmd.Context(), &ps.RunNekiShardConfigurationProfilesMaintenanceRequest{
+					Organization:              ch.Config.Organization,
+					Database:                  database,
+					Branch:                    branch,
+					ConfigurationProfileNames: profiles,
+				})
+			}
+			if err != nil {
+				profile := ""
+				if len(profiles) == 1 {
+					profile = profiles[0]
+				}
+				return handleError(err, database, branch, profile)
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				if len(profiles) == 1 {
+					ch.Printer.Printf("Maintenance for configuration profile %s was started.\n", printer.BoldBlue(profiles[0]))
+					return nil
+				}
+				ch.Printer.Printf("Maintenance for configuration profiles %s was started.\n", printer.BoldBlue(label))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(map[string]interface{}{
+				"result":                 "maintenance started",
+				"configuration_profiles": profiles,
+			})
+		},
+	}
+}
diff --git a/internal/cmd/configprofile/parameters.go b/internal/cmd/configprofile/parameters.go
new file mode 100644
index 000000000..f79592711
--- /dev/null
+++ b/internal/cmd/configprofile/parameters.go
@@ -0,0 +1,74 @@
+package configprofile
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ParametersCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		namespace string
+		extension bool
+		internal  bool
+	}
+
+	cmd := &cobra.Command{
+		Use:     "parameters <database> <branch> <name>",
+		Short:   "List parameters for a Neki configuration profile",
+		Args:    cmdutil.ExactArgs("database", "branch", "name"),
+		Aliases: []string{"params"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			request := &ps.ListNekiShardConfigurationProfileParametersRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: name,
+			}
+			if cmd.Flags().Changed("extension") {
+				request.Extension = &flags.extension
+			}
+			if cmd.Flags().Changed("internal") {
+				request.Internal = &flags.internal
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching parameters for configuration profile %s", printer.BoldBlue(name)))
+			defer end()
+			parameters, err := client.NekiShardConfigurationProfiles.ListParameters(cmd.Context(), request)
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+
+			if flags.namespace != "" {
+				filtered := make([]*ps.NekiParameter, 0, len(parameters))
+				for _, parameter := range parameters {
+					if parameter.Namespace == flags.namespace {
+						filtered = append(filtered, parameter)
+					}
+				}
+				parameters = filtered
+			}
+
+			if len(parameters) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No parameters found for configuration profile %s.\n", printer.BoldBlue(name))
+				return nil
+			}
+			return ch.Printer.PrintResource(toParameters(parameters))
+		},
+	}
+
+	cmd.Flags().StringVar(&flags.namespace, "namespace", "", "Only show parameters in this namespace")
+	cmd.Flags().BoolVar(&flags.extension, "extension", false, "Only show extension parameters")
+	cmd.Flags().BoolVar(&flags.internal, "internal", false, "Only show internal parameters")
+	return cmd
+}
diff --git a/internal/cmd/configprofile/set_default.go b/internal/cmd/configprofile/set_default.go
new file mode 100644
index 000000000..84135d9fd
--- /dev/null
+++ b/internal/cmd/configprofile/set_default.go
@@ -0,0 +1,44 @@
+package configprofile
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func SetDefaultCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:   "set-default <database> <branch> <name>",
+		Short: "Set the default Neki configuration profile",
+		Args:  cmdutil.ExactArgs("database", "branch", "name"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Setting configuration profile %s as default", printer.BoldBlue(name)))
+			defer end()
+			profile, err := client.NekiShardConfigurationProfiles.SetDefault(cmd.Context(), &ps.SetDefaultNekiShardConfigurationProfileRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: name,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Configuration profile %s is now the default for %s/%s.\n", printer.BoldBlue(profile.Name), printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+			return ch.Printer.PrintResource(toProfile(profile))
+		},
+	}
+}
diff --git a/internal/cmd/configprofile/show.go b/internal/cmd/configprofile/show.go
new file mode 100644
index 000000000..7a3fafc1f
--- /dev/null
+++ b/internal/cmd/configprofile/show.go
@@ -0,0 +1,40 @@
+package configprofile
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ShowCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:     "show <database> <branch> <name>",
+		Aliases: []string{"get"},
+		Short:   "Show a Neki configuration profile",
+		Args:    cmdutil.ExactArgs("database", "branch", "name"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, profile := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching configuration profile %s", printer.BoldBlue(profile)))
+			defer end()
+			result, err := client.NekiShardConfigurationProfiles.Get(cmd.Context(), &ps.GetNekiShardConfigurationProfileRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: profile,
+			})
+			if err != nil {
+				return handleError(err, database, branch, profile)
+			}
+			end()
+			return ch.Printer.PrintResource(toProfile(result))
+		},
+	}
+}
diff --git a/internal/cmd/configprofile/update.go b/internal/cmd/configprofile/update.go
new file mode 100644
index 000000000..babacfc69
--- /dev/null
+++ b/internal/cmd/configprofile/update.go
@@ -0,0 +1,100 @@
+package configprofile
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func UpdateCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		name, clusterSize string
+		replicas          int
+		parameters        []string
+		major, minor      string
+		storage           storageFlags
+	}
+	cmd := &cobra.Command{
+		Use:   "update <database> <branch> <name>",
+		Short: "Update a Neki configuration profile",
+		Args:  cmdutil.ExactArgs("database", "branch", "name"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, profileName := args[0], args[1], args[2]
+			changed := false
+			for _, name := range []string{"name", "cluster-size", "replicas", "parameters", "postgres-major-version", "postgres-minor-version"} {
+				changed = changed || cmd.Flags().Changed(name)
+			}
+			changed = changed || storageFlagChanged(cmd)
+			if !changed {
+				return fmt.Errorf("at least one update flag is required")
+			}
+			if cmd.Flags().Changed("postgres-minor-version") && !cmd.Flags().Changed("postgres-major-version") {
+				return fmt.Errorf("--postgres-major-version is required with --postgres-minor-version")
+			}
+
+			parameters, err := parseParameters(flags.parameters)
+			if err != nil {
+				return err
+			}
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Updating configuration profile %s", printer.BoldBlue(profileName)))
+			defer end()
+			profile, err := client.NekiShardConfigurationProfiles.Update(cmd.Context(), &ps.UpdateNekiShardConfigurationProfileRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: profileName,
+				Name:                 stringPointerIfChanged(cmd, "name", flags.name),
+				ClusterSize:          stringPointerIfChanged(cmd, "cluster-size", flags.clusterSize),
+				Replicas:             intPointerIfChanged(cmd, "replicas", flags.replicas),
+				Parameters:           parameters,
+				PostgresMajorVersion: stringPointerIfChanged(cmd, "postgres-major-version", flags.major),
+				PostgresMinorVersion: stringPointerIfChanged(cmd, "postgres-minor-version", flags.minor),
+				Storage:              storageFromFlags(cmd, flags.storage),
+			})
+			if err != nil {
+				return handleError(err, database, branch, profileName)
+			}
+			end()
+			return ch.Printer.PrintResource(toProfile(profile))
+		},
+	}
+	cmd.Flags().StringVar(&flags.name, "name", "", "New name for the configuration profile")
+	cmd.Flags().StringVar(&flags.clusterSize, "cluster-size", "", "New cluster size for shards in the profile")
+	cmd.Flags().IntVar(&flags.replicas, "replicas", 0, "New number of replicas for shards in the profile")
+	cmd.Flags().StringArrayVar(&flags.parameters, "parameters", nil, "Set a parameter as namespace.name=value; repeatable")
+	cmd.Flags().StringVar(&flags.major, "postgres-major-version", "", "PostgreSQL major version")
+	cmd.Flags().StringVar(&flags.minor, "postgres-minor-version", "", "PostgreSQL minor version")
+	bindStorageFlags(cmd, &flags.storage)
+	return cmd
+}
+
+func parseParameters(values []string) (map[string]map[string]string, error) {
+	if len(values) == 0 {
+		return nil, nil
+	}
+	out := make(map[string]map[string]string)
+	for _, value := range values {
+		key, setting, ok := strings.Cut(value, "=")
+		if !ok {
+			return nil, fmt.Errorf("invalid --parameters %q: expected namespace.name=value", value)
+		}
+		namespace, name, ok := strings.Cut(key, ".")
+		if !ok || namespace == "" || name == "" {
+			return nil, fmt.Errorf("invalid --parameters %q: expected namespace.name=value", value)
+		}
+		if out[namespace] == nil {
+			out[namespace] = make(map[string]string)
+		}
+		out[namespace][name] = setting
+	}
+	return out, nil
+}
diff --git a/internal/cmd/database/create.go b/internal/cmd/database/create.go
index 177286703..9681da3f3 100644
--- a/internal/cmd/database/create.go
+++ b/internal/cmd/database/create.go
@@ -57,8 +57,8 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
 				createReq.MajorVersion = flags.majorVersion
 			}
 
-			if (cmd.Flags().Changed("min-storage") || cmd.Flags().Changed("max-storage")) && engine != ps.DatabaseEnginePostgres {
-				return fmt.Errorf("--min-storage and --max-storage are only supported for PostgreSQL databases")
+			if (cmd.Flags().Changed("min-storage") || cmd.Flags().Changed("max-storage")) && engine != ps.DatabaseEnginePostgres && engine != ps.DatabaseEngineNeki {
+				return fmt.Errorf("--min-storage and --max-storage are only supported for Postgres or Neki databases")
 			}
 
 			if cmd.Flags().Changed("min-storage") || cmd.Flags().Changed("max-storage") {
@@ -127,17 +127,18 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
 
 	cmd.Flags().StringVar(&createReq.ClusterSize, "cluster-size", "", "cluster size for Scaler Pro databases. Use `pscale size cluster list` to see the valid sizes.")
 
-	flags.replicas = cmd.Flags().Int("replicas", 0, "number of replicas for postgresql database. 0 for single node, 2+ for HA.")
+	flags.replicas = cmd.Flags().Int("replicas", 0, "number of replicas for Postgres or Neki databases. Use 0 for single-node Postgres or 2 or more for HA.")
 
-	cmd.Flags().StringVar(&flags.engine, "engine", string(ps.DatabaseEngineMySQL), "The database engine for the database. Supported values: mysql, postgresql. Defaults to mysql.")
+	cmd.Flags().StringVar(&flags.engine, "engine", string(ps.DatabaseEngineMySQL), "The database engine for the database. Supported values: mysql, postgresql, neki. Defaults to mysql.")
 	cmd.RegisterFlagCompletionFunc("engine", func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
 		return []cobra.Completion{
 			cobra.CompletionWithDesc("mysql", "A Vitess database"),
 			cobra.CompletionWithDesc("postgresql", "The fastest cloud Postgres"),
+			cobra.CompletionWithDesc("neki", "Sharded PostgreSQL"),
 		}, cobra.ShellCompDirectiveNoFileComp
 	})
 
-	cmd.Flags().StringVar(&flags.majorVersion, "major-version", "", "For PostgreSQL databases, the PostgreSQL major version to use for the database. Defaults to the latest available major version.")
+	cmd.Flags().StringVar(&flags.majorVersion, "major-version", "", "For Postgres or Neki databases, the Postgres major version to use. Defaults to the latest available major version.")
 	cmd.RegisterFlagCompletionFunc("major-version", func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
 		return []cobra.Completion{
 			cobra.CompletionWithDesc("17", "PostgreSQL 17"),
@@ -211,8 +212,10 @@ func parseDatabaseEngine(engine string) (ps.DatabaseEngine, error) {
 		return ps.DatabaseEngineMySQL, nil
 	case "postgresql", "postgres":
 		return ps.DatabaseEnginePostgres, nil
+	case "neki":
+		return ps.DatabaseEngineNeki, nil
 	default:
-		return ps.DatabaseEngineMySQL, fmt.Errorf("invalid database engine %q, supported values: mysql, postgresql", engine)
+		return ps.DatabaseEngineMySQL, fmt.Errorf("invalid database engine %q, supported values: mysql, postgresql, neki", engine)
 	}
 }
 
@@ -221,6 +224,26 @@ func waitUntilReady(ctx context.Context, client *ps.Client, printer *printer.Pri
 	defer cancel()
 
 	startTime := time.Now()
+	poll := func() *ps.Database {
+		resp, err := client.Databases.Get(ctx, getReq)
+		if err != nil {
+			if debug {
+				printer.Printf("fetching database %s failed: %s", getReq.Database, err)
+			}
+			return nil
+		}
+
+		if resp.State == ps.DatabaseReady {
+			return resp
+		}
+
+		return nil
+	}
+
+	if database := poll(); database != nil {
+		return database, nil
+	}
+
 	var ticker *time.Ticker
 
 	// Start with 5-second interval for the first minute
@@ -232,16 +255,8 @@ func waitUntilReady(ctx context.Context, client *ps.Client, printer *printer.Pri
 		case <-ctx.Done():
 			return nil, errors.New("database creation timed out")
 		case <-ticker.C:
-			resp, err := client.Databases.Get(ctx, getReq)
-			if err != nil {
-				if debug {
-					printer.Printf("fetching database %s failed: %s", getReq.Database, err)
-				}
-				continue
-			}
-
-			if resp.State == ps.DatabaseReady {
-				return resp, nil
+			if database := poll(); database != nil {
+				return database, nil
 			}
 
 			elapsed := time.Since(startTime)
diff --git a/internal/cmd/database/create_test.go b/internal/cmd/database/create_test.go
index 6cbdf684a..c3affe8d0 100644
--- a/internal/cmd/database/create_test.go
+++ b/internal/cmd/database/create_test.go
@@ -5,6 +5,7 @@ import (
 	"context"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/planetscale/cli/internal/cmdutil"
 	"github.com/planetscale/cli/internal/config"
@@ -79,8 +80,20 @@ func TestDatabase_CreateCmdWithWaitPrintsReadyDatabase(t *testing.T) {
 
 	org := "planetscale"
 	db := "planetscale"
-	pending := &ps.Database{Name: db, State: ps.DatabasePending}
-	ready := &ps.Database{Name: db, State: ps.DatabaseReady}
+	createdAt := time.Date(2026, 8, 11, 23, 21, 50, 0, time.UTC)
+	readyAt := createdAt.Add(time.Minute)
+	pending := &ps.Database{
+		Name:      db,
+		State:     ps.DatabasePending,
+		CreatedAt: createdAt,
+		UpdatedAt: createdAt,
+	}
+	ready := &ps.Database{
+		Name:      db,
+		State:     ps.DatabaseReady,
+		CreatedAt: createdAt,
+		UpdatedAt: readyAt,
+	}
 
 	svc := &mock.DatabaseService{
 		CreateFn: func(_ context.Context, _ *ps.CreateDatabaseRequest) (*ps.Database, error) {
@@ -315,7 +328,7 @@ func TestDatabase_CreateCmdWithStorageMySQLError(t *testing.T) {
 	err := cmd.Execute()
 
 	c.Assert(err, qt.IsNotNil)
-	c.Assert(err, qt.ErrorMatches, ".*only supported for PostgreSQL.*")
+	c.Assert(err, qt.ErrorMatches, ".*only supported for Postgres or Neki.*")
 	c.Assert(svc.CreateFnInvoked, qt.IsFalse)
 }
 
@@ -431,6 +444,59 @@ func TestDatabase_CreateCmdPostgresWithMajorVersion(t *testing.T) {
 	c.Assert(buf.String(), qt.JSONEquals, res)
 }
 
+func TestDatabase_CreateCmdNeki(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(&buf)
+
+	org := "planetscale"
+	db := "planetscale"
+
+	res := &ps.Database{Name: "foo"}
+
+	svc := &mock.DatabaseService{
+		CreateFn: func(ctx context.Context, req *ps.CreateDatabaseRequest) (*ps.Database, error) {
+			c.Assert(req.Organization, qt.Equals, org)
+			c.Assert(req.Name, qt.Equals, db)
+			c.Assert(req.Region, qt.Equals, "us-east")
+			c.Assert(req.Kind, qt.Equals, ps.DatabaseEngineNeki)
+
+			return res, nil
+		},
+	}
+
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config: &config.Config{
+			Organization: org,
+		},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{
+				Databases: svc,
+				Organizations: &mock.OrganizationsService{
+					GetFn: func(ctx context.Context, request *ps.GetOrganizationRequest) (*ps.Organization, error) {
+						return &ps.Organization{
+							RemainingFreeDatabases: 1,
+							Name:                   request.Organization,
+						}, nil
+					},
+				},
+			}, nil
+		},
+	}
+
+	cmd := CreateCmd(ch)
+	cmd.SetArgs([]string{db, "--region", "us-east", "--engine", "neki"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(svc.CreateFnInvoked, qt.IsTrue)
+	c.Assert(buf.String(), qt.JSONEquals, res)
+}
+
 func TestDatabase_CreateCmdCloudflareBilling(t *testing.T) {
 	tests := []struct {
 		name  string
diff --git a/internal/cmd/keyspace/keyspace.go b/internal/cmd/keyspace/keyspace.go
index b61d563d4..fb11e6223 100644
--- a/internal/cmd/keyspace/keyspace.go
+++ b/internal/cmd/keyspace/keyspace.go
@@ -55,8 +55,6 @@ type Keyspace struct {
 type KeyspaceSettings struct {
 	ReplicationDurabilityConstraintStrategy string            `header:"replication durability constraint strategy" json:"replication_durability_constraint"`
 	VReplicationFlags                       VReplicationFlags `header:"inline" json:"vreplication_flags"`
-	DiskScalingStrategy                     string            `header:"disk scaling strategy" json:"disk_scaling_strategy"`
-	MaxStorageBytes                         int64             `header:"max storage bytes" json:"max_storage_bytes"`
 
 	orig *ps.Keyspace
 }
diff --git a/internal/cmd/keyspace/settings.go b/internal/cmd/keyspace/settings.go
index 1319baf06..11a9b4d85 100644
--- a/internal/cmd/keyspace/settings.go
+++ b/internal/cmd/keyspace/settings.go
@@ -84,13 +84,5 @@ func toKeyspaceSettings(ks *ps.Keyspace) *KeyspaceSettings {
 		}
 	}
 
-	// Set disk autoscaling settings if available
-	if ks.DiskAutoscaling != nil {
-		settings.DiskScalingStrategy = ks.DiskAutoscaling.Strategy
-		settings.MaxStorageBytes = ks.DiskAutoscaling.StorageLimitBytes
-	} else {
-		settings.DiskScalingStrategy = "not set"
-	}
-
 	return settings
 }
diff --git a/internal/cmd/keyspace/update_settings.go b/internal/cmd/keyspace/update_settings.go
index fad77552c..e92bef54d 100644
--- a/internal/cmd/keyspace/update_settings.go
+++ b/internal/cmd/keyspace/update_settings.go
@@ -3,29 +3,20 @@ package keyspace
 import (
 	"context"
 	"fmt"
-	"slices"
-	"strings"
 
 	"github.com/charmbracelet/huh"
-	"github.com/spf13/cobra"
-
 	"github.com/planetscale/cli/internal/cmdutil"
 	ps "github.com/planetscale/cli/internal/planetscale"
 	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
 )
 
-// diskScalingStrategies are the disk autoscaling strategies accepted by the
-// --disk-scaling-strategy flag.
-var diskScalingStrategies = []string{"grow", "disable", "shrink"}
-
 func UpdateSettingsCmd(ch *cmdutil.Helper) *cobra.Command {
 	updateReq := &ps.UpdateKeyspaceSettingsRequest{}
 
 	var flags struct {
 		replicationDurabilityConstraints *ps.ReplicationDurabilityConstraints
 		vreplicationFlags                *ps.VReplicationFlags
-		diskScalingStrategy              string
-		maxStorage                       int64
 		interactive                      bool
 	}
 
@@ -45,10 +36,6 @@ func UpdateSettingsCmd(ch *cmdutil.Helper) *cobra.Command {
 			updateReq.Branch = branch
 			updateReq.Keyspace = keyspace
 
-			if cmd.Flags().Changed("disk-scaling-strategy") && !slices.Contains(diskScalingStrategies, flags.diskScalingStrategy) {
-				return fmt.Errorf("invalid --disk-scaling-strategy %q, must be one of: %s", flags.diskScalingStrategy, strings.Join(diskScalingStrategies, ", "))
-			}
-
 			if flags.interactive {
 				return updateInteractive(ctx, ch, updateReq)
 			}
@@ -97,26 +84,7 @@ func UpdateSettingsCmd(ch *cmdutil.Helper) *cobra.Command {
 				}
 			}
 
-			// Check if any relevant flags are changing disk autoscaling settings
-			strategyChanged := cmd.Flags().Changed("disk-scaling-strategy")
-			maxStorageChanged := cmd.Flags().Changed("max-storage")
-			daChanged := strategyChanged || maxStorageChanged
-
-			if daChanged {
-				updateReq.DiskAutoscaling = &ps.DiskAutoscalingUpdate{}
-
-				if strategyChanged {
-					strategy := flags.diskScalingStrategy
-					updateReq.DiskAutoscaling.Strategy = &strategy
-				}
-
-				if maxStorageChanged {
-					maxStorage := flags.maxStorage
-					updateReq.DiskAutoscaling.StorageLimitBytes = &maxStorage
-				}
-			}
-
-			if !rdcChanged && !vrfChanged && !daChanged {
+			if !rdcChanged && !vrfChanged {
 				end()
 				ch.Printer.Println("No changes were requested. No update performed.")
 				return nil
@@ -137,12 +105,8 @@ func UpdateSettingsCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd.Flags().BoolVar(&flags.vreplicationFlags.OptimizeInserts, "vreplication-optimize-inserts", true, "When enabled, skips sending INSERT events for rows that have yet to be replicated.")
 	cmd.Flags().BoolVar(&flags.vreplicationFlags.AllowNoBlobBinlogRowImage, "vreplication-enable-noblob-binlog-mode", true, "When enabled, omits changed BLOB and TEXT columns from replication events, which reduces binlog sizes.")
 	cmd.Flags().BoolVar(&flags.vreplicationFlags.VPlayerBatching, "vreplication-batch-replication-events", false, "When enabled, sends fewer queries to MySQL to improve performance.")
-	cmd.Flags().StringVar(&flags.diskScalingStrategy, "disk-scaling-strategy", "grow", fmt.Sprintf("The disk autoscaling strategy (%s). 'grow' lets dedicated disks grow automatically up to the storage limit; 'disable' turns autoscaling off; 'shrink' recreates disks at their initial size and then disables autoscaling.", strings.Join(diskScalingStrategies, ", ")))
-	cmd.Flags().Int64Var(&flags.maxStorage, "max-storage", 0, "The maximum size in bytes that dedicated disks may autoscale to. Required when the strategy is 'grow'.")
 	cmd.Flags().BoolVarP(&flags.interactive, "interactive", "i", false, "Run the command in interactive mode")
 
-	_ = cmd.RegisterFlagCompletionFunc("disk-scaling-strategy", cobra.FixedCompletions(diskScalingStrategies, cobra.ShellCompDirectiveNoFileComp))
-
 	return cmd
 }
 
diff --git a/internal/cmd/keyspace/update_settings_test.go b/internal/cmd/keyspace/update_settings_test.go
index 5241bf052..fe2cccbf1 100644
--- a/internal/cmd/keyspace/update_settings_test.go
+++ b/internal/cmd/keyspace/update_settings_test.go
@@ -8,7 +8,6 @@ import (
 	"time"
 
 	qt "github.com/frankban/quicktest"
-
 	"github.com/planetscale/cli/internal/cmdutil"
 	"github.com/planetscale/cli/internal/config"
 	"github.com/planetscale/cli/internal/mock"
@@ -620,246 +619,6 @@ func TestKeyspace_UpdateSettingsCmd_PreserveNilValues(t *testing.T) {
 	c.Assert(buf.String(), qt.JSONEquals, updatedKs)
 }
 
-func TestKeyspace_UpdateSettingsCmd_DiskAutoscaling(t *testing.T) {
-	c := qt.New(t)
-
-	var buf bytes.Buffer
-	format := printer.JSON
-
-	p := printer.NewPrinter(&format)
-	p.SetResourceOutput(&buf)
-
-	org := "planetscale"
-	db := "planetscale"
-	branch := "main"
-	keyspace := "sharded"
-
-	ts := time.Now()
-
-	ks := &ps.Keyspace{
-		ID:        "ks1",
-		Name:      keyspace,
-		CreatedAt: ts,
-		UpdatedAt: ts,
-	}
-
-	updatedKs := &ps.Keyspace{
-		ID:        "ks1",
-		Name:      keyspace,
-		CreatedAt: ts,
-		UpdatedAt: ts,
-		DiskAutoscaling: &ps.DiskAutoscaling{
-			Strategy:          "grow",
-			StorageLimitBytes: 8796093022208,
-		},
-	}
-
-	svc := &mock.KeyspacesService{
-		GetFn: func(ctx context.Context, req *ps.GetKeyspaceRequest) (*ps.Keyspace, error) {
-			return ks, nil
-		},
-		UpdateSettingsFn: func(ctx context.Context, req *ps.UpdateKeyspaceSettingsRequest) (*ps.Keyspace, error) {
-			c.Assert(req.Database, qt.Equals, db)
-			c.Assert(req.Organization, qt.Equals, org)
-			c.Assert(req.Branch, qt.Equals, branch)
-			c.Assert(req.Keyspace, qt.Equals, keyspace)
-
-			c.Assert(req.DiskAutoscaling, qt.Not(qt.IsNil))
-			c.Assert(req.DiskAutoscaling.Strategy, qt.Not(qt.IsNil))
-			c.Assert(*req.DiskAutoscaling.Strategy, qt.Equals, "grow")
-			c.Assert(req.DiskAutoscaling.StorageLimitBytes, qt.Not(qt.IsNil))
-			c.Assert(*req.DiskAutoscaling.StorageLimitBytes, qt.Equals, int64(8796093022208))
-
-			return updatedKs, nil
-		},
-	}
-
-	ch := &cmdutil.Helper{
-		Printer: p,
-		Config: &config.Config{
-			Organization: org,
-		},
-		Client: func() (*ps.Client, error) {
-			return &ps.Client{
-				Keyspaces: svc,
-			}, nil
-		},
-	}
-
-	cmd := UpdateSettingsCmd(ch)
-	cmd.SetArgs([]string{
-		db,
-		branch,
-		keyspace,
-		"--disk-scaling-strategy=grow",
-		"--max-storage=8796093022208",
-	})
-	err := cmd.Execute()
-	c.Assert(err, qt.IsNil)
-	c.Assert(svc.GetFnInvoked, qt.IsTrue)
-	c.Assert(svc.UpdateSettingsFnInvoked, qt.IsTrue)
-	c.Assert(buf.String(), qt.JSONEquals, updatedKs)
-}
-
-func TestKeyspace_UpdateSettingsCmd_DiskAutoscalingInvalidStrategy(t *testing.T) {
-	c := qt.New(t)
-
-	var buf bytes.Buffer
-	format := printer.JSON
-
-	p := printer.NewPrinter(&format)
-	p.SetResourceOutput(&buf)
-
-	org := "planetscale"
-	db := "planetscale"
-	branch := "main"
-	keyspace := "sharded"
-
-	svc := &mock.KeyspacesService{}
-
-	ch := &cmdutil.Helper{
-		Printer: p,
-		Config: &config.Config{
-			Organization: org,
-		},
-		Client: func() (*ps.Client, error) {
-			return &ps.Client{
-				Keyspaces: svc,
-			}, nil
-		},
-	}
-
-	cmd := UpdateSettingsCmd(ch)
-	cmd.SetArgs([]string{
-		db,
-		branch,
-		keyspace,
-		"--disk-scaling-strategy=nonsense",
-	})
-	err := cmd.Execute()
-	c.Assert(err, qt.ErrorMatches, `invalid --disk-scaling-strategy "nonsense", must be one of: grow, disable, shrink`)
-	c.Assert(svc.GetFnInvoked, qt.IsFalse)
-	c.Assert(svc.UpdateSettingsFnInvoked, qt.IsFalse)
-}
-
-// When disk autoscaling flags are omitted, an update triggered by other flags
-// must not carry any disk autoscaling settings, so flag defaults don't
-// overwrite the keyspace's current settings on the server.
-func TestKeyspace_UpdateSettingsCmd_DiskAutoscalingNotSet(t *testing.T) {
-	c := qt.New(t)
-
-	var buf bytes.Buffer
-	format := printer.JSON
-
-	p := printer.NewPrinter(&format)
-	p.SetResourceOutput(&buf)
-
-	org := "planetscale"
-	db := "planetscale"
-	branch := "main"
-	keyspace := "sharded"
-
-	ts := time.Now()
-
-	ks := &ps.Keyspace{
-		ID:        "ks1",
-		Name:      keyspace,
-		CreatedAt: ts,
-		UpdatedAt: ts,
-		ReplicationDurabilityConstraints: &ps.ReplicationDurabilityConstraints{
-			Strategy: "available",
-		},
-	}
-
-	updatedKs := &ps.Keyspace{
-		ID:        "ks1",
-		Name:      keyspace,
-		CreatedAt: ts,
-		UpdatedAt: ts,
-		ReplicationDurabilityConstraints: &ps.ReplicationDurabilityConstraints{
-			Strategy: "lag",
-		},
-	}
-
-	svc := &mock.KeyspacesService{
-		GetFn: func(ctx context.Context, req *ps.GetKeyspaceRequest) (*ps.Keyspace, error) {
-			return ks, nil
-		},
-		UpdateSettingsFn: func(ctx context.Context, req *ps.UpdateKeyspaceSettingsRequest) (*ps.Keyspace, error) {
-			// Only an unrelated flag was passed, so no disk autoscaling
-			// settings should be sent.
-			c.Assert(req.DiskAutoscaling, qt.IsNil)
-
-			return updatedKs, nil
-		},
-	}
-
-	ch := &cmdutil.Helper{
-		Printer: p,
-		Config: &config.Config{
-			Organization: org,
-		},
-		Client: func() (*ps.Client, error) {
-			return &ps.Client{
-				Keyspaces: svc,
-			}, nil
-		},
-	}
-
-	cmd := UpdateSettingsCmd(ch)
-	cmd.SetArgs([]string{
-		db,
-		branch,
-		keyspace,
-		"--replication-durability-constraints-strategy=dynamic",
-	})
-	err := cmd.Execute()
-	c.Assert(err, qt.IsNil)
-	c.Assert(svc.GetFnInvoked, qt.IsTrue)
-	c.Assert(svc.UpdateSettingsFnInvoked, qt.IsTrue)
-}
-
-func TestKeyspace_UpdateSettingsCmd_NoFlagsUpdateNotPerformed(t *testing.T) {
-	c := qt.New(t)
-
-	var buf bytes.Buffer
-	format := printer.JSON
-
-	p := printer.NewPrinter(&format)
-	p.SetResourceOutput(&buf)
-
-	org := "planetscale"
-	db := "planetscale"
-	branch := "main"
-	keyspace := "sharded"
-
-	ks := &ps.Keyspace{ID: "ks1", Name: keyspace}
-
-	svc := &mock.KeyspacesService{
-		GetFn: func(ctx context.Context, req *ps.GetKeyspaceRequest) (*ps.Keyspace, error) {
-			return ks, nil
-		},
-	}
-
-	ch := &cmdutil.Helper{
-		Printer: p,
-		Config: &config.Config{
-			Organization: org,
-		},
-		Client: func() (*ps.Client, error) {
-			return &ps.Client{
-				Keyspaces: svc,
-			}, nil
-		},
-	}
-
-	cmd := UpdateSettingsCmd(ch)
-	cmd.SetArgs([]string{db, branch, keyspace})
-	err := cmd.Execute()
-	c.Assert(err, qt.IsNil)
-	c.Assert(svc.UpdateSettingsFnInvoked, qt.IsFalse)
-}
-
 func TestKeyspace_ConstraintsToStrategy(t *testing.T) {
 	c := qt.New(t)
 
diff --git a/internal/cmd/logs/logs.go b/internal/cmd/logs/logs.go
new file mode 100644
index 000000000..7cf202d05
--- /dev/null
+++ b/internal/cmd/logs/logs.go
@@ -0,0 +1,327 @@
+package logs
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+const (
+	defaultLimit  = 100
+	defaultPeriod = "1h"
+)
+
+var validPeriods = map[string]bool{
+	"15m": true,
+	"1h":  true,
+	"3h":  true,
+	"6h":  true,
+	"12h": true,
+	"1d":  true,
+	"7d":  true,
+	"8d":  true,
+}
+
+var validLevels = map[string]bool{
+	"ERROR":   true,
+	"DEBUG":   true,
+	"INFO":    true,
+	"WARNING": true,
+}
+
+type flags struct {
+	query   string
+	period  string
+	from    string
+	to      string
+	levels  []string
+	servers []string
+	shards  []string
+	limit   int
+	page    int
+}
+
+// LogEntry is a parsed branch log entry.
+type LogEntry struct {
+	Time             string `header:"time" json:"time" csv:"time"`
+	Level            string `header:"level" json:"level" csv:"level"`
+	Message          string `header:"message" json:"message" csv:"message"`
+	Role             string `header:"role" json:"role,omitempty" csv:"role"`
+	Shard            string `header:"shard" json:"shard,omitempty" csv:"shard"`
+	Container        string `header:"container" json:"container" csv:"container"`
+	AvailabilityZone string `header:"availability zone" json:"availability_zone" csv:"availability_zone"`
+	Pod              string `header:"pod" json:"pod" csv:"pod"`
+	StreamID         string `header:"stream id" json:"stream_id" csv:"stream_id"`
+	RawMessage       string `header:"raw message" json:"raw_message" csv:"raw_message"`
+}
+
+type outerLog struct {
+	Time             string `json:"_time"`
+	StreamID         string `json:"_stream_id"`
+	Message          string `json:"_msg"`
+	Level            string `json:"planetscale.level"`
+	Role             string `json:"planetscale.role"`
+	Shard            string `json:"planetscale.shard"`
+	Container        string `json:"planetscale.container"`
+	AvailabilityZone string `json:"planetscale.availability_zone"`
+	Pod              string `json:"planetscale.pod"`
+}
+
+type innerLog struct {
+	Message string `json:"message"`
+}
+
+// LogsCmd queries logs for a PostgreSQL or Neki branch.
+func LogsCmd(ch *cmdutil.Helper) *cobra.Command {
+	f := &flags{}
+
+	cmd := &cobra.Command{
+		Use:   "logs <database> <branch>",
+		Short: "Query logs for a PostgreSQL or Neki branch",
+		Long: `Query recent logs for a PostgreSQL or Neki branch.
+
+The command obtains a signed logs URL from the PlanetScale API, builds a LogsQL
+query, and prints parsed log entries. By default it returns up to 100 logs from
+the primary server over the last hour, newest first.`,
+		Example: `  # Recent primary logs
+  pscale logs <database> <branch> --org <org> --format json
+
+  # Errors from a selected pod over the last six hours
+  pscale logs <database> <branch> --org <org> --format json --period 6h --level ERROR --server <pod>
+
+  # Logs from a custom ISO 8601 time range
+  pscale logs <database> <branch> --org <org> --format json \
+    --from 2026-08-20T16:00:00Z --to 2026-08-20T18:00:00Z
+
+  # Search and filter with LogsQL syntax
+  pscale logs <database> <branch> --org <org> --format json --query 'connection refused'`,
+		Args:              cmdutil.RequiredArgs("database", "branch"),
+		PersistentPreRunE: cmdutil.CheckAuthentication(ch.Config),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := validateFlags(f, cmd.Flags().Changed("period")); err != nil {
+				return err
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			ctx := cmd.Context()
+			database, branch := args[0], args[1]
+			signature, err := client.Logs.CreateSignature(ctx, &ps.CreateLogSignatureRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return err
+			}
+
+			body, err := client.Logs.Query(ctx, &ps.QueryLogsRequest{
+				URL:   signature.URL,
+				Query: createQuery(f),
+				Limit: f.limit,
+			})
+			if err != nil {
+				return err
+			}
+			defer body.Close()
+
+			entries, err := parseLogs(body)
+			if err != nil {
+				return err
+			}
+
+			if len(entries) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No logs found for %s in %s.\n", printer.BoldBlue(branch), printer.BoldBlue(database))
+				return nil
+			}
+			if ch.Printer.Format() == printer.Human {
+				printHumanLogs(ch, entries)
+				return nil
+			}
+
+			return ch.Printer.PrintResource(entries)
+		},
+	}
+
+	cmd.PersistentFlags().StringVar(&ch.Config.Organization, "org", ch.Config.Organization,
+		"The organization for the current user")
+	cmd.Flags().StringVar(&f.query, "query", "", "Text or LogsQL expression to search for")
+	cmd.Flags().StringVar(&f.period, "period", defaultPeriod,
+		"Time period to query: 15m, 1h, 3h, 6h, 12h, 1d, 7d, or 8d")
+	cmd.Flags().StringVar(&f.from, "from", "", "Start of a custom time range as an ISO 8601 timestamp")
+	cmd.Flags().StringVar(&f.to, "to", "", "End of a custom time range as an ISO 8601 timestamp")
+	cmd.Flags().StringSliceVar(&f.levels, "level", nil,
+		"Log levels to include (comma-separated or repeatable): DEBUG, INFO, WARNING, ERROR")
+	cmd.Flags().StringSliceVar(&f.servers, "server", []string{"primary"},
+		"Servers to include (comma-separated or repeatable); primary selects the primary role, other values select pod names")
+	cmd.Flags().StringSliceVar(&f.shards, "shard", nil,
+		"Neki shards to include (comma-separated or repeatable)")
+	cmd.Flags().IntVar(&f.limit, "limit", defaultLimit, "Maximum number of logs to return")
+	cmd.Flags().IntVar(&f.page, "page", 1, "Page number to fetch")
+	cmd.MarkPersistentFlagRequired("org") // nolint:errcheck
+
+	return cmd
+}
+
+func printHumanLogs(ch *cmdutil.Helper, entries []*LogEntry) {
+	for _, entry := range entries {
+		message := strings.ReplaceAll(entry.Message, "\r\n", `\n`)
+		message = strings.ReplaceAll(message, "\r", `\r`)
+		message = strings.ReplaceAll(message, "\n", `\n`)
+		message = strings.ReplaceAll(message, "\t", `\t`)
+		ch.Printer.Printf("%s %-7s %s\n", entry.Time, entry.Level, message)
+	}
+}
+
+func validateFlags(f *flags, periodChanged bool) error {
+	if (f.from == "") != (f.to == "") {
+		return fmt.Errorf("--from and --to must be used together")
+	}
+	if f.from != "" && periodChanged {
+		return fmt.Errorf("--period cannot be combined with --from and --to")
+	}
+	if !validPeriods[f.period] {
+		return fmt.Errorf("invalid --period %q, must be one of: 15m, 1h, 3h, 6h, 12h, 1d, 7d, 8d", f.period)
+	}
+	if f.limit <= 0 {
+		return fmt.Errorf("--limit must be greater than zero")
+	}
+	if f.page <= 0 {
+		return fmt.Errorf("--page must be greater than zero")
+	}
+
+	for i, level := range f.levels {
+		level = strings.ToUpper(level)
+		if !validLevels[level] {
+			return fmt.Errorf("invalid --level %q, must be one of: DEBUG, INFO, WARNING, ERROR", f.levels[i])
+		}
+		f.levels[i] = level
+	}
+
+	return nil
+}
+
+func createQuery(f *flags) string {
+	parts := strings.Split(strings.TrimSpace(f.query), "|")
+	filter := strings.TrimSpace(parts[0])
+	if filter == "" {
+		filter = "*"
+	}
+
+	timeFilter := f.period
+	if f.from != "" {
+		timeFilter = fmt.Sprintf("[%s, %s]", f.from, f.to)
+	}
+	query := []string{filter, "_time:" + timeFilter}
+
+	if len(f.levels) > 0 {
+		levels := make([]string, 0, len(f.levels))
+		for _, level := range f.levels {
+			levels = append(levels, "planetscale.level:"+level)
+		}
+		query = append(query, "("+strings.Join(levels, " OR ")+")")
+	}
+
+	if len(f.shards) > 0 {
+		shards := make([]string, 0, len(f.shards))
+		for _, shard := range f.shards {
+			shards = append(shards, "planetscale.shard:"+shard)
+		}
+		query = append(query, "("+strings.Join(shards, " OR ")+")")
+	}
+
+	if len(f.servers) > 0 {
+		servers := make([]string, 0, len(f.servers))
+		for _, server := range f.servers {
+			if server == "" {
+				continue
+			}
+			if server == "primary" {
+				servers = append(servers, "planetscale.role:primary")
+			} else {
+				servers = append(servers, "planetscale.pod:"+server)
+			}
+		}
+		if len(servers) > 0 {
+			query = append(query, "("+strings.Join(servers, " OR ")+")")
+		}
+	}
+
+	for _, pipeline := range parts[1:] {
+		pipeline = strings.TrimSpace(pipeline)
+		if pipeline != "" {
+			query = append(query, "| "+pipeline)
+		}
+	}
+
+	offset := (f.page - 1) * f.limit
+	query = append(query, fmt.Sprintf("| sort by (_time desc) | offset %d", offset))
+
+	return strings.Join(query, " ")
+}
+
+func parseLogs(r io.Reader) ([]*LogEntry, error) {
+	entries := make([]*LogEntry, 0)
+	scanner := bufio.NewScanner(r)
+	scanner.Buffer(make([]byte, 64*1024), 16*1024*1024)
+
+	for scanner.Scan() {
+		entry, ok := parseLog(scanner.Bytes())
+		if ok {
+			entries = append(entries, entry)
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("reading branch logs: %w", err)
+	}
+
+	return entries, nil
+}
+
+func parseLog(raw []byte) (*LogEntry, bool) {
+	if len(raw) == 0 {
+		return nil, false
+	}
+
+	var outer outerLog
+	if err := json.Unmarshal(raw, &outer); err != nil || outer.Message == "" {
+		return nil, false
+	}
+
+	message := outer.Message
+	var inner innerLog
+	if err := json.Unmarshal([]byte(outer.Message), &inner); err == nil {
+		if inner.Message == "" {
+			return nil, false
+		}
+		message = inner.Message
+	}
+
+	level := outer.Level
+	if level == "" {
+		level = "INFO"
+	}
+
+	return &LogEntry{
+		Time:             outer.Time,
+		Level:            level,
+		Message:          message,
+		Role:             outer.Role,
+		Shard:            outer.Shard,
+		Container:        outer.Container,
+		AvailabilityZone: outer.AvailabilityZone,
+		Pod:              outer.Pod,
+		StreamID:         outer.StreamID,
+		RawMessage:       outer.Message,
+	}, true
+}
diff --git a/internal/cmd/logs/logs_test.go b/internal/cmd/logs/logs_test.go
new file mode 100644
index 000000000..6c34fb6eb
--- /dev/null
+++ b/internal/cmd/logs/logs_test.go
@@ -0,0 +1,287 @@
+package logs
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/config"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+func TestCreateQueryMatchesAppQueryShape(t *testing.T) {
+	tests := []struct {
+		name  string
+		flags *flags
+		want  string
+	}{
+		{
+			name:  "defaults",
+			flags: &flags{period: "1h", servers: []string{"primary"}, limit: 100, page: 1},
+			want:  "* _time:1h (planetscale.role:primary) | sort by (_time desc) | offset 0",
+		},
+		{
+			name: "filters pagination and pipeline",
+			flags: &flags{
+				query:   "timeout | unpack_json | fields _msg",
+				period:  "6h",
+				levels:  []string{"ERROR", "WARNING"},
+				servers: []string{"primary", "pod-2"},
+				shards:  []string{"shard-1", "shard-2"},
+				limit:   25,
+				page:    3,
+			},
+			want: "timeout _time:6h (planetscale.level:ERROR OR planetscale.level:WARNING) " +
+				"(planetscale.shard:shard-1 OR planetscale.shard:shard-2) " +
+				"(planetscale.role:primary OR planetscale.pod:pod-2) " +
+				"| unpack_json | fields _msg | sort by (_time desc) | offset 50",
+		},
+		{
+			name:  "all servers",
+			flags: &flags{period: "1h", servers: nil, limit: 100, page: 1},
+			want:  "* _time:1h | sort by (_time desc) | offset 0",
+		},
+		{
+			name: "custom time range",
+			flags: &flags{
+				period:  "1h",
+				from:    "2026-08-20T16:00:00Z",
+				to:      "2026-08-20T18:00:00Z",
+				servers: []string{"primary"},
+				limit:   100,
+				page:    1,
+			},
+			want: "* _time:[2026-08-20T16:00:00Z, 2026-08-20T18:00:00Z] " +
+				"(planetscale.role:primary) | sort by (_time desc) | offset 0",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := createQuery(tt.flags); got != tt.want {
+				t.Fatalf("query = %q\nwant  = %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestValidateFlags(t *testing.T) {
+	f := &flags{period: "1h", levels: []string{"error"}, limit: 100, page: 1}
+	if err := validateFlags(f, false); err != nil {
+		t.Fatal(err)
+	}
+	if f.levels[0] != "ERROR" {
+		t.Fatalf("normalized level = %q, want ERROR", f.levels[0])
+	}
+
+	for _, tt := range []struct {
+		name          string
+		f             *flags
+		periodChanged bool
+		want          string
+	}{
+		{name: "period", f: &flags{period: "2h", limit: 100, page: 1}, want: "invalid --period"},
+		{name: "limit", f: &flags{period: "1h", limit: 0, page: 1}, want: "--limit must be greater"},
+		{name: "page", f: &flags{period: "1h", limit: 100, page: 0}, want: "--page must be greater"},
+		{name: "level", f: &flags{period: "1h", levels: []string{"TRACE"}, limit: 100, page: 1}, want: "invalid --level"},
+		{name: "from without to", f: &flags{period: "1h", from: "2026-08-20T16:00:00Z", limit: 100, page: 1}, want: "--from and --to must be used together"},
+		{name: "to without from", f: &flags{period: "1h", to: "2026-08-20T18:00:00Z", limit: 100, page: 1}, want: "--from and --to must be used together"},
+		{
+			name:          "range with explicit period",
+			f:             &flags{period: "1h", from: "2026-08-20T16:00:00Z", to: "2026-08-20T18:00:00Z", limit: 100, page: 1},
+			periodChanged: true,
+			want:          "--period cannot be combined with --from and --to",
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateFlags(tt.f, tt.periodChanged)
+			if err == nil || !strings.Contains(err.Error(), tt.want) {
+				t.Fatalf("error = %v, want containing %q", err, tt.want)
+			}
+		})
+	}
+}
+
+func TestParseLogsMatchesAppBehavior(t *testing.T) {
+	raw := strings.Join([]string{
+		`{"_time":"2026-08-21T12:00:00Z","_stream_id":"stream-1","_msg":"{\"message\":\"database started\"}","planetscale.level":"DEBUG","planetscale.role":"primary","planetscale.shard":"s1","planetscale.container":"postgres","planetscale.availability_zone":"us-east-1a","planetscale.pod":"pod-1"}`,
+		`{"_time":"2026-08-21T12:01:00Z","_stream_id":"stream-2","_msg":"plain message","planetscale.container":"postgres","planetscale.availability_zone":"us-east-1b","planetscale.pod":"pod-2"}`,
+		`not json`,
+		`{"_msg":"{\"other\":\"missing message\"}"}`,
+	}, "\n")
+
+	entries, err := parseLogs(strings.NewReader(raw))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(entries) != 2 {
+		t.Fatalf("got %d entries, want 2", len(entries))
+	}
+	if entries[0].Message != "database started" || entries[0].RawMessage != `{"message":"database started"}` {
+		t.Fatalf("unexpected nested entry: %#v", entries[0])
+	}
+	if entries[1].Message != "plain message" || entries[1].Level != "INFO" {
+		t.Fatalf("unexpected plain entry: %#v", entries[1])
+	}
+}
+
+func TestPrintHumanLogsLineOriented(t *testing.T) {
+	format := printer.Human
+	var out bytes.Buffer
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	ch := &cmdutil.Helper{Printer: p}
+
+	printHumanLogs(ch, []*LogEntry{
+		{Time: "2026-08-21T12:00:00Z", Level: "ERROR", Message: "connection refused"},
+		{Time: "2026-08-21T12:00:01Z", Level: "INFO", Message: "first line\nsecond\tcolumn"},
+	})
+
+	want := "2026-08-21T12:00:00Z ERROR   connection refused\n" +
+		`2026-08-21T12:00:01Z INFO    first line\nsecond\tcolumn` + "\n"
+	if got := out.String(); got != want {
+		t.Fatalf("human output = %q, want %q", got, want)
+	}
+}
+
+func TestLogsCmdPrinterFormatsAndSignedQuery(t *testing.T) {
+	for _, format := range []printer.Format{printer.Human, printer.JSON, printer.CSV} {
+		t.Run(format.String(), func(t *testing.T) {
+			wantLogsQuery := "failed _time:6h (planetscale.level:ERROR OR planetscale.level:WARNING) " +
+				"(planetscale.shard:s1 OR planetscale.shard:s2) " +
+				"(planetscale.role:primary OR planetscale.pod:pod-2) " +
+				"| fields _msg | sort by (_time desc) | offset 50"
+			args := []string{"db", "main", "--org", "acme", "--query", "failed | fields _msg", "--period", "6h", "--level", "error,warning", "--server", "primary,pod-2", "--shard", "s1,s2", "--limit", "25", "--page", "3"}
+			if format == printer.JSON {
+				wantLogsQuery = "failed _time:[2026-08-20T16:00:00Z, 2026-08-20T18:00:00Z] " +
+					"(planetscale.level:ERROR OR planetscale.level:WARNING) " +
+					"(planetscale.shard:s1 OR planetscale.shard:s2) " +
+					"(planetscale.role:primary OR planetscale.pod:pod-2) " +
+					"| fields _msg | sort by (_time desc) | offset 50"
+				args = []string{"db", "main", "--org", "acme", "--query", "failed | fields _msg", "--from", "2026-08-20T16:00:00Z", "--to", "2026-08-20T18:00:00Z", "--level", "error,warning", "--server", "primary,pod-2", "--shard", "s1,s2", "--limit", "25", "--page", "3"}
+			}
+
+			var serverURL string
+			mux := http.NewServeMux()
+			mux.HandleFunc("/v1/organizations/acme/databases/db/branches/main/logs/signatures", func(w http.ResponseWriter, r *http.Request) {
+				if r.Method != http.MethodPost {
+					t.Fatalf("method = %s, want POST", r.Method)
+				}
+				if got := r.Header.Get("Authorization"); got != "Bearer token" {
+					t.Fatalf("authorization = %q, want Bearer token", got)
+				}
+				_ = json.NewEncoder(w).Encode(map[string]string{
+					"sig": "signature",
+					"exp": "999",
+					"url": serverURL + "/signed?sig=signature&exp=999",
+				})
+			})
+			mux.HandleFunc("/signed", func(w http.ResponseWriter, r *http.Request) {
+				if got := r.Header.Get("Authorization"); got != "" {
+					t.Fatalf("logs request leaked authorization %q", got)
+				}
+				assertSignedQuery(t, r.URL.Query(), wantLogsQuery)
+				_, _ = io.WriteString(w, strings.Join([]string{
+					`{"_time":"2026-08-21T12:00:00Z","_stream_id":"stream-1","_msg":"{\"message\":\"database started\"}","planetscale.level":"ERROR","planetscale.role":"primary","planetscale.shard":"s1","planetscale.container":"postgres","planetscale.availability_zone":"us-east-1a","planetscale.pod":"pod-1"}`,
+					`malformed`,
+				}, "\n"))
+			})
+
+			server := httptest.NewServer(mux)
+			serverURL = server.URL
+			t.Cleanup(server.Close)
+
+			var out bytes.Buffer
+			ch := logsTestHelper(server.URL, format, &out)
+			cmd := LogsCmd(ch)
+			cmd.SetArgs(args)
+			if err := cmd.Execute(); err != nil {
+				t.Fatal(err)
+			}
+
+			switch format {
+			case printer.JSON:
+				var entries []*LogEntry
+				if err := json.Unmarshal(out.Bytes(), &entries); err != nil {
+					t.Fatalf("invalid JSON output %q: %v", out.String(), err)
+				}
+				if len(entries) != 1 || entries[0].Message != "database started" || entries[0].Level != "ERROR" {
+					t.Fatalf("unexpected JSON entries: %#v", entries)
+				}
+			case printer.CSV:
+				if !strings.Contains(out.String(), "time,level,message") || !strings.Contains(out.String(), "database started") {
+					t.Fatalf("unexpected CSV output: %q", out.String())
+				}
+			case printer.Human:
+				want := "2026-08-21T12:00:00Z ERROR   database started\n"
+				if got := out.String(); got != want {
+					t.Fatalf("human output = %q, want %q", got, want)
+				}
+			}
+		})
+	}
+}
+
+func TestLogsCmdSignedEndpointFailure(t *testing.T) {
+	var serverURL string
+	mux := http.NewServeMux()
+	mux.HandleFunc("/v1/organizations/acme/databases/db/branches/main/logs/signatures", func(w http.ResponseWriter, r *http.Request) {
+		_ = json.NewEncoder(w).Encode(map[string]string{"url": serverURL + "/signed"})
+	})
+	mux.HandleFunc("/signed", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusServiceUnavailable)
+		_, _ = fmt.Fprint(w, "logs are warming up")
+	})
+
+	server := httptest.NewServer(mux)
+	serverURL = server.URL
+	t.Cleanup(server.Close)
+
+	var out bytes.Buffer
+	cmd := LogsCmd(logsTestHelper(server.URL, printer.JSON, &out))
+	cmd.SetArgs([]string{"db", "main", "--org", "acme"})
+	err := cmd.Execute()
+	if err == nil || !strings.Contains(err.Error(), "HTTP 503 Service Unavailable: logs are warming up") {
+		t.Fatalf("error = %v", err)
+	}
+}
+
+func assertSignedQuery(t *testing.T, query url.Values, wantLogsQuery string) {
+	t.Helper()
+	for key, want := range map[string]string{
+		"sig":   "signature",
+		"exp":   "999",
+		"limit": "25",
+		"query": wantLogsQuery,
+	} {
+		if got := query.Get(key); got != want {
+			t.Fatalf("%s = %q, want %q", key, got, want)
+		}
+	}
+}
+
+func logsTestHelper(baseURL string, format printer.Format, out *bytes.Buffer) *cmdutil.Helper {
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(out)
+	p.SetHumanOutput(out)
+
+	return &cmdutil.Helper{
+		Printer: p,
+		Config: &config.Config{
+			AccessToken:  "token",
+			Organization: "acme",
+			BaseURL:      baseURL,
+		},
+		Client: func() (*ps.Client, error) {
+			return ps.NewClient(ps.WithBaseURL(baseURL), ps.WithAccessToken("token"))
+		},
+	}
+}
diff --git a/internal/cmd/role/create.go b/internal/cmd/role/create.go
index 20f715a58..f035b1b9d 100644
--- a/internal/cmd/role/create.go
+++ b/internal/cmd/role/create.go
@@ -20,7 +20,7 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
 
 	cmd := &cobra.Command{
 		Use:   "create <database> <branch> <name>",
-		Short: "Create a new role for a Postgres database branch",
+		Short: "Create a new role for a Postgres or Neki database branch",
 		Args:  cmdutil.RequiredArgs("database", "branch", "name"),
 		Example: `  # Create a role with admin access
   pscale role create mydb main my-role --inherited-roles postgres
@@ -80,7 +80,7 @@ func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
 				return nil
 			}
 
-			return ch.Printer.PrintResource(toPostgresRole(role))
+			return printRole(ch.Printer, role)
 		},
 	}
 	cmd.PersistentFlags().Var(&flags.ttl, "ttl", `TTL defines the time to live for the role. Durations such as "30m", "24h", or bare integers such as "3600" (seconds) are accepted. The default TTL is 0s, which means the role will never expire.`)
diff --git a/internal/cmd/role/get.go b/internal/cmd/role/get.go
index 33f74a4e3..fbebab359 100644
--- a/internal/cmd/role/get.go
+++ b/internal/cmd/role/get.go
@@ -85,12 +85,19 @@ func GetCmd(ch *cmdutil.Helper) *cobra.Command {
 			}
 			end()
 
-			output := toPostgresRole(role)
 			if flags.bouncer != "" {
-				output.DatabaseURL = buildPostgresConnectionURLWithDefaultPort(role.Username, role.Password, role.AccessHostURL, "6432")
+				bouncerURL := buildPostgresConnectionURLWithDefaultPort(role.Username, role.Password, role.AccessHostURL, "6432")
+				if isNekiRole(role) {
+					output := toNekiRole(role)
+					output.DatabaseURL = bouncerURL
+					return ch.Printer.PrintResource(output)
+				}
+				output := toPostgresRole(role)
+				output.DatabaseURL = bouncerURL
+				return ch.Printer.PrintResource(output)
 			}
 
-			return ch.Printer.PrintResource(output)
+			return printRole(ch.Printer, role)
 		},
 	}
 
diff --git a/internal/cmd/role/list.go b/internal/cmd/role/list.go
index 7090fabd1..e23e4566c 100644
--- a/internal/cmd/role/list.go
+++ b/internal/cmd/role/list.go
@@ -22,7 +22,7 @@ func ListCmd(ch *cmdutil.Helper) *cobra.Command {
 
 	cmd := &cobra.Command{
 		Use:     "list <database> <branch>",
-		Short:   "List all roles for a Postgres database branch",
+		Short:   "List all roles for a Postgres or Neki database branch",
 		Args:    cmdutil.RequiredArgs("database", "branch"),
 		Aliases: []string{"ls"},
 		RunE: func(cmd *cobra.Command, args []string) error {
@@ -90,7 +90,7 @@ func ListCmd(ch *cmdutil.Helper) *cobra.Command {
 				return nil
 			}
 
-			return ch.Printer.PrintResource(toPostgresRoles(roles))
+			return printRoleList(ch.Printer, roles)
 		},
 	}
 
@@ -118,6 +118,28 @@ type PostgresRoleList struct {
 	orig *ps.PostgresRole
 }
 
+type NekiRoleList struct {
+	PublicID        string  `header:"id" json:"id"`
+	Name            string  `header:"name" json:"name"`
+	Username        string  `header:"username" json:"username"`
+	Ready           bool    `header:"ready" json:"ready"`
+	Status          string  `header:"status" json:"status"`
+	ExpiresAt       *string `header:"expires_at" json:"expires_at"`
+	AccessHostURL   string  `header:"access_host_url" json:"access_host_url"`
+	WithReplication bool    `header:"with_replication" json:"with_replication"`
+	CreatedAt       string  `header:"created_at" json:"created_at"`
+
+	orig *ps.PostgresRole
+}
+
+func printRoleList(p *printer.Printer, roles []*ps.PostgresRole) error {
+	if len(roles) > 0 && isNekiRole(roles[0]) {
+		return p.PrintResource(toNekiRoles(roles))
+	}
+
+	return p.PrintResource(toPostgresRoles(roles))
+}
+
 func toPostgresRoles(roles []*ps.PostgresRole) []*PostgresRoleList {
 	psRoles := make([]*PostgresRoleList, 0, len(roles))
 
@@ -137,3 +159,24 @@ func toPostgresRoles(roles []*ps.PostgresRole) []*PostgresRoleList {
 
 	return psRoles
 }
+
+func toNekiRoles(roles []*ps.PostgresRole) []*NekiRoleList {
+	nekiRoles := make([]*NekiRoleList, 0, len(roles))
+
+	for _, role := range roles {
+		nekiRoles = append(nekiRoles, &NekiRoleList{
+			PublicID:        role.ID,
+			Name:            role.Name,
+			Username:        role.Username,
+			AccessHostURL:   role.AccessHostURL,
+			WithReplication: role.WithReplication,
+			Ready:           role.Ready,
+			Status:          postgresRoleStatus(role),
+			ExpiresAt:       postgresRoleExpiresAt(role),
+			CreatedAt:       role.CreatedAt.Format("2006-01-02 15:04:05"),
+			orig:            role,
+		})
+	}
+
+	return nekiRoles
+}
diff --git a/internal/cmd/role/output_test.go b/internal/cmd/role/output_test.go
new file mode 100644
index 000000000..d70d7e2ca
--- /dev/null
+++ b/internal/cmd/role/output_test.go
@@ -0,0 +1,302 @@
+package role
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/config"
+	"github.com/planetscale/cli/internal/mock"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestRoleStatus(t *testing.T) {
+	disabledAt := time.Date(2026, time.August, 19, 12, 0, 0, 0, time.UTC)
+
+	tests := []struct {
+		name string
+		role *ps.PostgresRole
+		want string
+	}{
+		{name: "active", role: &ps.PostgresRole{}, want: "active"},
+		{name: "expired", role: &ps.PostgresRole{Expired: true}, want: "expired"},
+		{
+			name: "disabled takes precedence over expired",
+			role: &ps.PostgresRole{DisabledAt: &disabledAt, Expired: true},
+			want: "disabled",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := qt.New(t)
+
+			c.Assert(postgresRoleStatus(tt.role), qt.Equals, tt.want)
+		})
+	}
+}
+
+func TestPrintRoleListJSON(t *testing.T) {
+	expiresAt := time.Date(2026, time.August, 20, 17, 30, 0, 0, time.UTC)
+	disabledAt := time.Date(2026, time.August, 19, 12, 0, 0, 0, time.UTC)
+
+	tests := []struct {
+		name          string
+		role          *ps.PostgresRole
+		wantReady     *bool
+		wantStatus    string
+		wantExpiresAt any
+	}{
+		{
+			name: "Postgres omits ready",
+			role: &ps.PostgresRole{
+				Type:       "BranchRole",
+				ID:         "postgres-role",
+				Ready:      true,
+				DisabledAt: &disabledAt,
+				Expired:    true,
+				ExpiresAt:  &expiresAt,
+			},
+			wantStatus:    "disabled",
+			wantExpiresAt: "2026-08-20T17:30:00Z",
+		},
+		{
+			name: "Neki pending and expired without expiration",
+			role: &ps.PostgresRole{
+				Type:    "NekiRole",
+				ID:      "pending-neki-role",
+				Ready:   false,
+				Expired: true,
+			},
+			wantReady:     boolPointer(false),
+			wantStatus:    "expired",
+			wantExpiresAt: nil,
+		},
+		{
+			name: "Neki ready and active",
+			role: &ps.PostgresRole{
+				Type:      "NekiRole",
+				ID:        "ready-neki-role",
+				Ready:     true,
+				ExpiresAt: &expiresAt,
+			},
+			wantReady:     boolPointer(true),
+			wantStatus:    "active",
+			wantExpiresAt: "2026-08-20T17:30:00Z",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := qt.New(t)
+			var buf bytes.Buffer
+			format := printer.JSON
+			p := printer.NewPrinter(&format)
+			p.SetResourceOutput(&buf)
+
+			err := printRoleList(p, []*ps.PostgresRole{tt.role})
+
+			c.Assert(err, qt.IsNil)
+			var output []map[string]any
+			c.Assert(json.Unmarshal(buf.Bytes(), &output), qt.IsNil)
+			c.Assert(output, qt.HasLen, 1)
+			c.Assert(output[0]["status"], qt.Equals, tt.wantStatus)
+			c.Assert(output[0]["expires_at"], qt.Equals, tt.wantExpiresAt)
+			ready, hasReady := output[0]["ready"]
+			if tt.wantReady == nil {
+				c.Assert(hasReady, qt.IsFalse)
+			} else {
+				c.Assert(hasReady, qt.IsTrue)
+				c.Assert(ready, qt.Equals, *tt.wantReady)
+			}
+		})
+	}
+}
+
+func TestPrintRoleListHuman(t *testing.T) {
+	expiresAt := time.Date(2026, time.August, 20, 17, 30, 0, 0, time.UTC)
+
+	tests := []struct {
+		name             string
+		role             *ps.PostgresRole
+		wantReadyColumn  bool
+		wantOutputValues []string
+	}{
+		{
+			name: "Postgres",
+			role: &ps.PostgresRole{
+				Type:      "BranchRole",
+				ID:        "postgres-role",
+				ExpiresAt: &expiresAt,
+			},
+			wantOutputValues: []string{"STATUS", "EXPIRES AT", "active", "2026-08-20T17:30:00Z"},
+		},
+		{
+			name: "Neki",
+			role: &ps.PostgresRole{
+				Type:    "NekiRole",
+				ID:      "neki-role",
+				Ready:   false,
+				Expired: true,
+			},
+			wantReadyColumn:  true,
+			wantOutputValues: []string{"STATUS", "EXPIRES AT", "expired", "No"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := qt.New(t)
+			var buf bytes.Buffer
+			format := printer.Human
+			p := printer.NewPrinter(&format)
+			p.SetResourceOutput(&buf)
+
+			err := printRoleList(p, []*ps.PostgresRole{tt.role})
+
+			c.Assert(err, qt.IsNil)
+			output := buf.String()
+			for _, value := range tt.wantOutputValues {
+				c.Assert(output, qt.Contains, value)
+			}
+			c.Assert(strings.Contains(output, "READY"), qt.Equals, tt.wantReadyColumn)
+		})
+	}
+}
+
+func TestRoleGetOutput(t *testing.T) {
+	expiresAt := time.Date(2026, time.August, 20, 17, 30, 0, 0, time.UTC)
+
+	tests := []struct {
+		name       string
+		format     printer.Format
+		role       *ps.PostgresRole
+		wantReady  *bool
+		wantValues []string
+	}{
+		{
+			name:   "Postgres JSON",
+			format: printer.JSON,
+			role: &ps.PostgresRole{
+				Type:      "BranchRole",
+				ID:        "postgres-role",
+				Ready:     true,
+				ExpiresAt: &expiresAt,
+			},
+			wantValues: []string{"active", "2026-08-20T17:30:00Z"},
+		},
+		{
+			name:   "Neki JSON",
+			format: printer.JSON,
+			role: &ps.PostgresRole{
+				Type:    "NekiRole",
+				ID:      "neki-role",
+				Ready:   false,
+				Expired: true,
+			},
+			wantReady:  boolPointer(false),
+			wantValues: []string{"expired"},
+		},
+		{
+			name:   "Postgres human",
+			format: printer.Human,
+			role: &ps.PostgresRole{
+				Type:      "BranchRole",
+				ID:        "postgres-role",
+				ExpiresAt: &expiresAt,
+			},
+			wantValues: []string{"STATUS", "EXPIRES AT", "active", "2026-08-20T17:30:00Z"},
+		},
+		{
+			name:   "Neki human",
+			format: printer.Human,
+			role: &ps.PostgresRole{
+				Type:  "NekiRole",
+				ID:    "neki-role",
+				Ready: true,
+			},
+			wantReady:  boolPointer(true),
+			wantValues: []string{"READY", "STATUS", "EXPIRES AT", "Yes", "active"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := qt.New(t)
+			var resourceOutput bytes.Buffer
+			format := tt.format
+			p := printer.NewPrinter(&format)
+			p.SetHumanOutput(&bytes.Buffer{})
+			p.SetResourceOutput(&resourceOutput)
+
+			svc := &mock.PostgresRolesService{
+				GetFn: func(context.Context, *ps.GetPostgresRoleRequest) (*ps.PostgresRole, error) {
+					return tt.role, nil
+				},
+			}
+			ch := &cmdutil.Helper{
+				Printer: p,
+				Config:  &config.Config{Organization: "planetscale"},
+				Client: func() (*ps.Client, error) {
+					return &ps.Client{PostgresRoles: svc}, nil
+				},
+			}
+
+			cmd := GetCmd(ch)
+			cmd.SetArgs([]string{"database", "main", tt.role.ID})
+			err := cmd.Execute()
+
+			c.Assert(err, qt.IsNil)
+			output := resourceOutput.String()
+			for _, value := range tt.wantValues {
+				c.Assert(output, qt.Contains, value)
+			}
+			if tt.format == printer.JSON {
+				var decoded map[string]any
+				c.Assert(json.Unmarshal(resourceOutput.Bytes(), &decoded), qt.IsNil)
+				ready, hasReady := decoded["ready"]
+				if tt.wantReady == nil {
+					c.Assert(hasReady, qt.IsFalse)
+				} else {
+					c.Assert(hasReady, qt.IsTrue)
+					c.Assert(ready, qt.Equals, *tt.wantReady)
+				}
+			}
+		})
+	}
+}
+
+func TestPrintPostgresRoleCredentialsKeepsLifecycleFieldsOut(t *testing.T) {
+	c := qt.New(t)
+	var buf bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&buf)
+
+	printPostgresRoleCredentials(p, &PostgresRole{
+		PublicID:  "role-id",
+		Status:    "active",
+		ExpiresAt: stringPointer("2026-08-20T17:30:00Z"),
+	})
+
+	output := buf.String()
+	c.Assert(output, qt.Contains, "ID")
+	c.Assert(output, qt.Not(qt.Contains), "STATUS")
+	c.Assert(output, qt.Not(qt.Contains), "EXPIRES")
+	c.Assert(output, qt.Not(qt.Contains), "READY")
+}
+
+func boolPointer(value bool) *bool {
+	return &value
+}
+
+func stringPointer(value string) *string {
+	return &value
+}
diff --git a/internal/cmd/role/renew.go b/internal/cmd/role/renew.go
index 0e3f7249b..719ee8157 100644
--- a/internal/cmd/role/renew.go
+++ b/internal/cmd/role/renew.go
@@ -56,7 +56,7 @@ func RenewCmd(ch *cmdutil.Helper) *cobra.Command {
 					printer.BoldBlue(roleID), printer.BoldBlue(database), printer.BoldBlue(branch))
 			}
 
-			return ch.Printer.PrintResource(toPostgresRole(role))
+			return printRole(ch.Printer, role)
 		},
 	}
 
diff --git a/internal/cmd/role/reset.go b/internal/cmd/role/reset.go
index 3b68bb162..b2c79ea76 100644
--- a/internal/cmd/role/reset.go
+++ b/internal/cmd/role/reset.go
@@ -99,7 +99,7 @@ func ResetCmd(ch *cmdutil.Helper) *cobra.Command {
 				return nil
 			}
 
-			return ch.Printer.PrintResource(toPostgresRole(role))
+			return printRole(ch.Printer, role)
 		},
 	}
 
diff --git a/internal/cmd/role/reset_default.go b/internal/cmd/role/reset_default.go
index d8b0f34a9..cc1353676 100644
--- a/internal/cmd/role/reset_default.go
+++ b/internal/cmd/role/reset_default.go
@@ -101,7 +101,7 @@ func ResetDefaultCmd(ch *cmdutil.Helper) *cobra.Command {
 				return nil
 			}
 
-			return ch.Printer.PrintResource(toPostgresRole(role))
+			return printRole(ch.Printer, role)
 		},
 	}
 
@@ -124,6 +124,21 @@ type PostgresRole struct {
 	orig *ps.PostgresRole
 }
 
+type NekiRole struct {
+	PublicID        string  `header:"id" json:"id"`
+	Name            string  `header:"name" json:"name"`
+	Username        string  `header:"username" json:"username"`
+	Ready           bool    `header:"ready" json:"ready"`
+	Status          string  `header:"status" json:"status"`
+	ExpiresAt       *string `header:"expires_at" json:"expires_at"`
+	Password        string  `header:"password" json:"password"`
+	AccessHostURL   string  `header:"access_host_url" json:"access_host_url"`
+	DatabaseURL     string  `header:"database_url" json:"database_url"`
+	WithReplication bool    `header:"with_replication" json:"with_replication"`
+
+	orig *ps.PostgresRole
+}
+
 func toPostgresRole(role *ps.PostgresRole) *PostgresRole {
 	return &PostgresRole{
 		PublicID:        role.ID,
@@ -139,6 +154,34 @@ func toPostgresRole(role *ps.PostgresRole) *PostgresRole {
 	}
 }
 
+func toNekiRole(role *ps.PostgresRole) *NekiRole {
+	return &NekiRole{
+		PublicID:        role.ID,
+		Name:            role.Name,
+		Username:        role.Username,
+		Ready:           role.Ready,
+		Status:          postgresRoleStatus(role),
+		ExpiresAt:       postgresRoleExpiresAt(role),
+		Password:        role.Password,
+		AccessHostURL:   role.AccessHostURL,
+		DatabaseURL:     buildPostgresConnectionURL(role.Username, role.Password, role.AccessHostURL),
+		WithReplication: role.WithReplication,
+		orig:            role,
+	}
+}
+
+func printRole(p *printer.Printer, role *ps.PostgresRole) error {
+	if isNekiRole(role) {
+		return p.PrintResource(toNekiRole(role))
+	}
+
+	return p.PrintResource(toPostgresRole(role))
+}
+
+func isNekiRole(role *ps.PostgresRole) bool {
+	return role.Type == "NekiRole"
+}
+
 func postgresRoleStatus(role *ps.PostgresRole) string {
 	if role.DisabledAt != nil {
 		return "disabled"
diff --git a/internal/cmd/role/role.go b/internal/cmd/role/role.go
index ee5988ae8..23b8971a0 100644
--- a/internal/cmd/role/role.go
+++ b/internal/cmd/role/role.go
@@ -8,8 +8,8 @@ import (
 func RoleCmd(ch *cmdutil.Helper) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:               "role",
-		Short:             "Manage database roles for a Postgres database branch",
-		Long:              "Manage database roles for a Postgres database branch.\n\nThis command is only supported for Postgres databases.",
+		Short:             "Manage database roles for a Postgres or Neki database branch",
+		Long:              "Manage database roles for a Postgres or Neki database branch.\n\nThis command is supported for Postgres or Neki databases.",
 		PersistentPreRunE: cmdutil.CheckAuthentication(ch.Config),
 	}
 
diff --git a/internal/cmd/role/update.go b/internal/cmd/role/update.go
index e6a99af4e..2d8ab8fec 100644
--- a/internal/cmd/role/update.go
+++ b/internal/cmd/role/update.go
@@ -64,7 +64,7 @@ func UpdateCmd(ch *cmdutil.Helper) *cobra.Command {
 					printer.BoldBlue(roleID), printer.BoldBlue(database), printer.BoldBlue(branch))
 			}
 
-			return ch.Printer.PrintResource(toPostgresRole(role))
+			return printRole(ch.Printer, role)
 		},
 	}
 
diff --git a/internal/cmd/root.go b/internal/cmd/root.go
index a26c8fe05..56d97e6aa 100644
--- a/internal/cmd/root.go
+++ b/internal/cmd/root.go
@@ -49,6 +49,7 @@ import (
 	"github.com/planetscale/cli/internal/cmd/insights"
 	"github.com/planetscale/cli/internal/cmd/inspect"
 	"github.com/planetscale/cli/internal/cmd/keyspace"
+	"github.com/planetscale/cli/internal/cmd/logs"
 	"github.com/planetscale/cli/internal/cmd/maintenance"
 	"github.com/planetscale/cli/internal/cmd/metrics"
 	"github.com/planetscale/cli/internal/cmd/org"
@@ -265,10 +266,7 @@ func runCmd(ctx context.Context, ver, commit, buildDate string, format *printer.
 		Long:  clicontent.AgentGuide,
 	})
 
-	rootCmd.AddGroup(&cobra.Group{ID: "database", Title: printer.Bold("MySQL & PostgreSQL database commands:")})
-	rootCmd.AddGroup(&cobra.Group{ID: "vitess", Title: printer.Bold("Vitess/MySQL-specific commands:")})
-	rootCmd.AddGroup(&cobra.Group{ID: "postgres", Title: printer.Bold("PostgreSQL-specific commands:")})
-	rootCmd.AddGroup(&cobra.Group{ID: "platform", Title: printer.Bold("Platform & account management:")})
+	addCommandGroups(rootCmd)
 
 	loginCmd := auth.LoginCmd(ch)
 	loginCmd.Hidden = true
@@ -331,7 +329,7 @@ func runCmd(ctx context.Context, ver, commit, buildDate string, format *printer.
 	versionCmd.GroupID = "platform"
 	rootCmd.AddCommand(versionCmd)
 
-	// Database management commands (Both databases)
+	// Database management commands shared across database engines.
 	backupCmd := backup.BackupCmd(ch)
 	backupCmd.GroupID = "database"
 	rootCmd.AddCommand(backupCmd)
@@ -352,6 +350,10 @@ func runCmd(ctx context.Context, ver, commit, buildDate string, format *printer.
 	inspectCmd.GroupID = "database"
 	rootCmd.AddCommand(inspectCmd)
 
+	logsCmd := logs.LogsCmd(ch)
+	logsCmd.GroupID = "database"
+	rootCmd.AddCommand(logsCmd)
+
 	metricsCmd := metrics.MetricsCmd(ch)
 	metricsCmd.GroupID = "database"
 	rootCmd.AddCommand(metricsCmd)
@@ -402,7 +404,7 @@ func runCmd(ctx context.Context, ver, commit, buildDate string, format *printer.
 	rootCmd.AddCommand(workflowCmd)
 
 	roleCmd := role.RoleCmd(ch)
-	roleCmd.GroupID = "postgres"
+	roleCmd.GroupID = "database"
 	rootCmd.AddCommand(roleCmd)
 
 	pgbouncerCmd := pgbouncer.Cmd(ch)
@@ -422,6 +424,13 @@ func runCmd(ctx context.Context, ver, commit, buildDate string, format *printer.
 	return rootCmd.ExecuteContext(ctx)
 }
 
+func addCommandGroups(cmd *cobra.Command) {
+	cmd.AddGroup(&cobra.Group{ID: "database", Title: printer.Bold("MySQL, Postgres, and Neki database commands:")})
+	cmd.AddGroup(&cobra.Group{ID: "vitess", Title: printer.Bold("Vitess/MySQL-specific commands:")})
+	cmd.AddGroup(&cobra.Group{ID: "postgres", Title: printer.Bold("PostgreSQL-specific commands:")})
+	cmd.AddGroup(&cobra.Group{ID: "platform", Title: printer.Bold("Platform & account management:")})
+}
+
 // annotateRequiredFlags walks the command tree and appends "(required)" to the
 // usage text of every flag marked as required, so it's visible in --help.
 func annotateRequiredFlags(cmd *cobra.Command) {
diff --git a/internal/cmd/root_test.go b/internal/cmd/root_test.go
index 52daecbd3..0f5613dd5 100644
--- a/internal/cmd/root_test.go
+++ b/internal/cmd/root_test.go
@@ -15,6 +15,17 @@ import (
 	"github.com/spf13/cobra"
 )
 
+func TestAddCommandGroupsOmitsNeki(t *testing.T) {
+	cmd := &cobra.Command{Use: "pscale"}
+	addCommandGroups(cmd)
+
+	for _, group := range cmd.Groups() {
+		if group.ID == "neki" {
+			t.Fatal("Neki command group should live under branch, not pscale root")
+		}
+	}
+}
+
 const rootCLIHelperEnv = "PSCALE_ROOT_CLI_HELPER"
 
 func TestRootSkillFlag(t *testing.T) {
diff --git a/internal/cmd/router/changes.go b/internal/cmd/router/changes.go
new file mode 100644
index 000000000..2a0736274
--- /dev/null
+++ b/internal/cmd/router/changes.go
@@ -0,0 +1,158 @@
+package router
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ChangesCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "changes <command>",
+		Short: "Manage changes to a Neki router",
+	}
+	cmd.AddCommand(changesListCmd(ch), changesShowCmd(ch), changesCancelCmd(ch))
+	return cmd
+}
+
+func changesListCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		period      string
+		completedAt string
+		page        int
+		perPage     int
+	}
+
+	cmd := &cobra.Command{
+		Use:     "list <database> <branch> <router>",
+		Short:   "List changes for a Neki router",
+		Args:    cmdutil.ExactArgs("database", "branch", "router"),
+		Aliases: []string{"ls"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, router := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching changes for router %s", printer.BoldBlue(router)))
+			defer end()
+			changes, err := client.NekiRouters.ListChanges(cmd.Context(), &ps.ListNekiRouterChangesRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Router:       router,
+				Period:       flags.period,
+				CompletedAt:  flags.completedAt,
+				Page:         flags.page,
+				PerPage:      flags.perPage,
+			})
+			if err != nil {
+				return handleError(err, database, branch, router)
+			}
+			end()
+
+			if len(changes) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No changes found for router %s.\n", printer.BoldBlue(router))
+				return nil
+			}
+			return ch.Printer.PrintResource(toChanges(changes))
+		},
+	}
+
+	cmd.Flags().StringVar(&flags.period, "period", "", "Only show changes from this period")
+	cmd.Flags().StringVar(&flags.completedAt, "completed-at", "", "Only show changes completed at this time")
+	cmd.Flags().IntVar(&flags.page, "page", 0, "Page number to fetch")
+	cmd.Flags().IntVar(&flags.perPage, "per-page", 100, "Number of results per page")
+	return cmd
+}
+
+func changesShowCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:     "show <database> <branch> <router> <change-id>",
+		Short:   "Show a change to a Neki router",
+		Args:    cmdutil.ExactArgs("database", "branch", "router", "change-id"),
+		Aliases: []string{"get"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, router, changeID := args[0], args[1], args[2], args[3]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching change %s", printer.BoldBlue(changeID)))
+			defer end()
+			change, err := client.NekiRouters.GetChange(cmd.Context(), &ps.GetNekiRouterChangeRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Router:       router,
+				Change:       changeID,
+			})
+			if err != nil {
+				return handleError(err, database, branch, router)
+			}
+			end()
+			if ch.Printer.Format() == printer.Human {
+				if err := ch.Printer.PrintResource(toChange(change)); err != nil {
+					return err
+				}
+
+				differences := changeDifferences(change)
+				if len(differences) == 0 {
+					ch.Printer.Println("No configuration differences.")
+					return nil
+				}
+
+				ch.Printer.Println("Changes:")
+				for _, difference := range differences {
+					ch.Printer.Printf("  %s: %s → %s\n", difference.Field, difference.Before, difference.After)
+				}
+				return nil
+			}
+			return ch.Printer.PrintResource(toChange(change))
+		},
+	}
+}
+
+func changesCancelCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:   "cancel <database> <branch> <router> <change-id>",
+		Short: "Cancel a pending change to a Neki router",
+		Args:  cmdutil.ExactArgs("database", "branch", "router", "change-id"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, router, changeID := args[0], args[1], args[2], args[3]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Cancelling change %s", printer.BoldBlue(changeID)))
+			defer end()
+			err = client.NekiRouters.CancelChange(cmd.Context(), &ps.CancelNekiRouterChangeRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Router:       router,
+				Change:       changeID,
+			})
+			if err != nil {
+				return handleError(err, database, branch, router)
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Canceled change %s for router %s.\n", printer.BoldBlue(changeID), printer.BoldBlue(router))
+				return nil
+			}
+			return ch.Printer.PrintResource(map[string]string{
+				"result":    "change canceled",
+				"change_id": changeID,
+				"router":    router,
+			})
+		},
+	}
+}
diff --git a/internal/cmd/router/create.go b/internal/cmd/router/create.go
new file mode 100644
index 000000000..16cc1eded
--- /dev/null
+++ b/internal/cmd/router/create.go
@@ -0,0 +1,60 @@
+package router
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		size            string
+		replicasPerCell int
+	}
+
+	cmd := &cobra.Command{
+		Use:   "create <database> <branch> <name>",
+		Short: "Create a router for a Neki database branch",
+		Args:  cmdutil.ExactArgs("database", "branch", "name"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Creating router %s in %s/%s", printer.BoldBlue(name), printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			request := &ps.CreateNekiRouterRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Name:         name,
+				RouterSize:   cmdutil.ToSizeSKUName(flags.size),
+			}
+			if cmd.Flags().Changed("replicas-per-cell") {
+				request.ReplicasPerCell = &flags.replicasPerCell
+			}
+
+			router, err := client.NekiRouters.Create(cmd.Context(), request)
+			if err != nil {
+				return handleError(err, database, branch, "")
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Router %s was successfully created in %s/%s.\n", printer.BoldBlue(router.Name), printer.BoldBlue(database), printer.BoldBlue(branch))
+			}
+			return ch.Printer.PrintResource(toRouter(router))
+		},
+	}
+
+	cmd.Flags().StringVar(&flags.size, "size", "", "Router size SKU (e.g. NKR-5); the API picks a default if omitted")
+	cmd.Flags().IntVar(&flags.replicasPerCell, "replicas-per-cell", 0, "Number of replicas in each cell")
+
+	return cmd
+}
diff --git a/internal/cmd/router/delete.go b/internal/cmd/router/delete.go
new file mode 100644
index 000000000..01c4a8e5a
--- /dev/null
+++ b/internal/cmd/router/delete.go
@@ -0,0 +1,63 @@
+package router
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func DeleteCmd(ch *cmdutil.Helper) *cobra.Command {
+	var force bool
+
+	cmd := &cobra.Command{
+		Use:     "delete <database> <branch> <name>",
+		Short:   "Delete a router from a Neki database branch",
+		Args:    cmdutil.ExactArgs("database", "branch", "name"),
+		Aliases: []string{"rm"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name := args[0], args[1], args[2]
+			if !force {
+				confirmationName := fmt.Sprintf("%s/%s/%s", database, branch, name)
+				if err := ch.Printer.ConfirmCommand(confirmationName, "delete router", "deletion of router"); err != nil {
+					return err
+				}
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Deleting router %s from %s/%s", printer.BoldBlue(name), printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			err = client.NekiRouters.Delete(cmd.Context(), &ps.DeleteNekiRouterRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Router:       name,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Router %s was successfully deleted from %s/%s.\n", printer.BoldBlue(name), printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(map[string]string{
+				"result": "router deleted",
+				"router": name,
+				"branch": branch,
+			})
+		},
+	}
+
+	cmd.Flags().BoolVar(&force, "force", false, "Delete the router without confirmation")
+	return cmd
+}
diff --git a/internal/cmd/router/errors.go b/internal/cmd/router/errors.go
new file mode 100644
index 000000000..a6f80b369
--- /dev/null
+++ b/internal/cmd/router/errors.go
@@ -0,0 +1,23 @@
+package router
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+func handleError(err error, database, branch, router string) error {
+	if cmdutil.ErrCode(err) != ps.ErrNotFound {
+		return cmdutil.HandleError(err)
+	}
+
+	if router != "" {
+		return fmt.Errorf("router %s does not exist in branch %s of database %s",
+			printer.BoldBlue(router), printer.BoldBlue(branch), printer.BoldBlue(database))
+	}
+
+	return fmt.Errorf("database %s or branch %s does not exist, or the branch is not a Neki branch",
+		printer.BoldBlue(database), printer.BoldBlue(branch))
+}
diff --git a/internal/cmd/router/list.go b/internal/cmd/router/list.go
new file mode 100644
index 000000000..4044cf919
--- /dev/null
+++ b/internal/cmd/router/list.go
@@ -0,0 +1,48 @@
+package router
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ListCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "list <database> <branch>",
+		Short:   "List routers for a Neki database branch",
+		Args:    cmdutil.ExactArgs("database", "branch"),
+		Aliases: []string{"ls"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching routers for %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			routers, err := client.NekiRouters.List(cmd.Context(), &ps.ListNekiRoutersRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return handleError(err, database, branch, "")
+			}
+			end()
+
+			if len(routers) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No routers found in %s/%s.\n", printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(toRouters(routers))
+		},
+	}
+
+	return cmd
+}
diff --git a/internal/cmd/router/router.go b/internal/cmd/router/router.go
new file mode 100644
index 000000000..553bda408
--- /dev/null
+++ b/internal/cmd/router/router.go
@@ -0,0 +1,319 @@
+package router
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/spf13/cobra"
+)
+
+func RouterCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "router <command>",
+		Short: "Manage routers for a Neki database branch",
+		Long:  "Manage routers for a Neki database branch.\n\nThis command is only supported for Neki databases.",
+	}
+
+	cmd.AddCommand(
+		ChangesCmd(ch),
+		CreateCmd(ch),
+		DeleteCmd(ch),
+		ListCmd(ch),
+		ShowCmd(ch),
+		SizesCmd(ch),
+		UpdateCmd(ch),
+	)
+
+	return cmd
+}
+
+type routerDisplay struct {
+	Name                 string `header:"name" json:"name"`
+	Default              bool   `header:"default" json:"default"`
+	Size                 string `header:"size" json:"size"`
+	ReplicasPerCell      int    `header:"replicas per cell" json:"replicas_per_cell"`
+	Autoscaling          bool   `header:"autoscaling" json:"autoscaling"`
+	MaxReplicasPerCell   string `header:"max replicas per cell" json:"max_replicas_per_cell"`
+	TargetCPUUtilization string `header:"target cpu utilization" json:"target_cpu_utilization"`
+	State                string `header:"state" json:"state"`
+	CreatedAt            string `header:"created at" json:"created_at"`
+
+	orig *ps.NekiRouter
+}
+
+func (r *routerDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(r.orig)
+}
+
+func (r *routerDisplay) MarshalCSVValue() interface{} {
+	return []*routerDisplay{r}
+}
+
+func toRouter(router *ps.NekiRouter) *routerDisplay {
+	size := "-"
+	if router.SKU != nil {
+		size = router.SKU.Name
+		if router.SKU.DisplayName != "" {
+			size = router.SKU.DisplayName
+		}
+	}
+
+	return &routerDisplay{
+		Name:                 router.Name,
+		Default:              router.Default,
+		Size:                 size,
+		ReplicasPerCell:      router.ReplicasPerCell,
+		Autoscaling:          router.Autoscaling,
+		MaxReplicasPerCell:   intOrDash(router.MaxReplicasPerCell),
+		TargetCPUUtilization: intOrDash(router.TargetCPUUtilization),
+		State:                router.State,
+		CreatedAt:            router.CreatedAt.UTC().Format("2006-01-02 15:04:05"),
+		orig:                 router,
+	}
+}
+
+func toRouters(routers []*ps.NekiRouter) []*routerDisplay {
+	out := make([]*routerDisplay, 0, len(routers))
+	for _, router := range routers {
+		out = append(out, toRouter(router))
+	}
+	return out
+}
+
+type routerDetailDisplay struct {
+	*routerDisplay
+
+	parameters []*ps.NekiParameter
+}
+
+func (r *routerDetailDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		*ps.NekiRouter
+		Parameters []*ps.NekiParameter `json:"parameters"`
+	}{NekiRouter: r.orig, Parameters: r.parameters})
+}
+
+func toRouterDetail(router *ps.NekiRouter, parameters []*ps.NekiParameter) *routerDetailDisplay {
+	return &routerDetailDisplay{routerDisplay: toRouter(router), parameters: parameters}
+}
+
+type parameterDisplay struct {
+	Namespace string `header:"namespace" json:"namespace"`
+	Name      string `header:"name" json:"name"`
+	Value     string `header:"value" json:"value"`
+	Default   string `header:"default" json:"default_value"`
+	Type      string `header:"type" json:"parameter_type"`
+	Restart   bool   `header:"restart" json:"restart"`
+
+	orig *ps.NekiParameter
+}
+
+func (p *parameterDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(p.orig)
+}
+
+func (p *parameterDisplay) MarshalCSVValue() interface{} {
+	return []*parameterDisplay{p}
+}
+
+func toParameters(parameters []*ps.NekiParameter) []*parameterDisplay {
+	out := make([]*parameterDisplay, 0, len(parameters))
+	for _, parameter := range parameters {
+		out = append(out, &parameterDisplay{
+			Namespace: parameter.Namespace,
+			Name:      parameter.Name,
+			Value:     formatValue(parameter.Value),
+			Default:   formatValue(parameter.DefaultValue),
+			Type:      parameter.ParameterType,
+			Restart:   parameter.Restart,
+			orig:      parameter,
+		})
+	}
+	return out
+}
+
+func formatValue(v interface{}) string {
+	switch value := v.(type) {
+	case nil:
+		return ""
+	case string:
+		return value
+	case float64:
+		return strconv.FormatFloat(value, 'f', -1, 64)
+	default:
+		return fmt.Sprintf("%v", value)
+	}
+}
+
+func intOrDash(v *int) string {
+	if v == nil {
+		return "-"
+	}
+	return strconv.Itoa(*v)
+}
+
+type changeDisplay struct {
+	ID        string `header:"id" json:"id"`
+	State     string `header:"state" json:"state"`
+	Changes   string `header:"changes" json:"changes"`
+	CreatedAt string `header:"created at" json:"created_at"`
+	orig      *ps.NekiRouterChange
+}
+
+func (c *changeDisplay) MarshalJSON() ([]byte, error) { return json.Marshal(c.orig) }
+func (c *changeDisplay) MarshalCSVValue() interface{} { return []*changeDisplay{c} }
+
+func toChange(c *ps.NekiRouterChange) *changeDisplay {
+	return &changeDisplay{
+		ID:        c.ID,
+		State:     c.State,
+		Changes:   formatChangeSummary(c),
+		CreatedAt: c.CreatedAt.UTC().Format("2006-01-02 15:04:05"),
+		orig:      c,
+	}
+}
+
+func formatChangeSummary(change *ps.NekiRouterChange) string {
+	differences := changeDifferences(change)
+	if len(differences) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(differences))
+	for _, difference := range differences {
+		parts = append(parts, fmt.Sprintf("%s: %s → %s", difference.Field, difference.Before, difference.After))
+	}
+	return strings.Join(parts, ", ")
+}
+
+func toChanges(changes []*ps.NekiRouterChange) []*changeDisplay {
+	out := make([]*changeDisplay, 0, len(changes))
+	for _, change := range changes {
+		out = append(out, toChange(change))
+	}
+	return out
+}
+
+type changeDifference struct {
+	Field  string
+	Before string
+	After  string
+}
+
+func changeSize(name, displayName string) string {
+	if displayName != "" {
+		return displayName
+	}
+	return name
+}
+
+func changeDifferences(change *ps.NekiRouterChange) []changeDifference {
+	differences := make([]changeDifference, 0)
+	before := changeSize(change.PreviousRouterSize, change.PreviousRouterSizeDisplayName)
+	after := changeSize(change.RouterSize, change.RouterSizeDisplayName)
+	if before != after {
+		differences = append(differences, changeDifference{Field: "Size", Before: before, After: after})
+	}
+	if change.PreviousReplicasPerCell != change.ReplicasPerCell {
+		differences = append(differences, changeDifference{
+			Field:  "Replicas per cell",
+			Before: strconv.Itoa(change.PreviousReplicasPerCell),
+			After:  strconv.Itoa(change.ReplicasPerCell),
+		})
+	}
+	if optionalBoolChanged(change.PreviousAutoscaling, change.Autoscaling) {
+		differences = append(differences, changeDifference{
+			Field:  "Autoscaling",
+			Before: formatOptionalBool(change.PreviousAutoscaling),
+			After:  formatOptionalBool(change.Autoscaling),
+		})
+	}
+	if optionalIntChanged(change.PreviousMaxReplicasPerCell, change.MaxReplicasPerCell) {
+		differences = append(differences, changeDifference{
+			Field:  "Max replicas per cell",
+			Before: formatOptionalInt(change.PreviousMaxReplicasPerCell),
+			After:  formatOptionalInt(change.MaxReplicasPerCell),
+		})
+	}
+	if optionalIntChanged(change.PreviousTargetCPUUtilization, change.TargetCPUUtilization) {
+		differences = append(differences, changeDifference{
+			Field:  "Target CPU utilization",
+			Before: formatOptionalInt(change.PreviousTargetCPUUtilization),
+			After:  formatOptionalInt(change.TargetCPUUtilization),
+		})
+	}
+
+	parameterKeys := make(map[string]struct{})
+	for namespace, parameters := range change.PreviousParameters {
+		for name := range parameters {
+			parameterKeys[namespace+"."+name] = struct{}{}
+		}
+	}
+	for namespace, parameters := range change.Parameters {
+		for name := range parameters {
+			parameterKeys[namespace+"."+name] = struct{}{}
+		}
+	}
+
+	keys := make([]string, 0, len(parameterKeys))
+	for key := range parameterKeys {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	for _, key := range keys {
+		namespace, name, _ := strings.Cut(key, ".")
+		before, hadBefore := change.PreviousParameters[namespace][name]
+		after, hasAfter := change.Parameters[namespace][name]
+		if hadBefore && hasAfter && before == after {
+			continue
+		}
+		if !hadBefore {
+			before = "(default)"
+		}
+		if !hasAfter {
+			after = "(default)"
+		}
+		differences = append(differences, changeDifference{Field: "Parameter " + key, Before: before, After: after})
+	}
+
+	return differences
+}
+
+func optionalBoolChanged(before, after *bool) bool {
+	if before == nil && after == nil {
+		return false
+	}
+	if before == nil || after == nil {
+		return true
+	}
+	return *before != *after
+}
+
+func optionalIntChanged(before, after *int) bool {
+	if before == nil && after == nil {
+		return false
+	}
+	if before == nil || after == nil {
+		return true
+	}
+	return *before != *after
+}
+
+func formatOptionalBool(v *bool) string {
+	if v == nil {
+		return "(default)"
+	}
+	return strconv.FormatBool(*v)
+}
+
+func formatOptionalInt(v *int) string {
+	if v == nil {
+		return "(default)"
+	}
+	return strconv.Itoa(*v)
+}
diff --git a/internal/cmd/router/router_test.go b/internal/cmd/router/router_test.go
new file mode 100644
index 000000000..1e325c604
--- /dev/null
+++ b/internal/cmd/router/router_test.go
@@ -0,0 +1,471 @@
+package router
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/config"
+	"github.com/planetscale/cli/internal/mock"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func routerTestHelper(svc ps.NekiRoutersService, out *bytes.Buffer) *cmdutil.Helper {
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(out)
+	return &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiRouters: svc}, nil
+		},
+	}
+}
+
+func testRouter() *ps.NekiRouter {
+	return &ps.NekiRouter{
+		Type:            "neki_router",
+		Name:            "default",
+		Default:         true,
+		SKU:             &ps.NekiRouterSKU{Name: "NKR_5", DisplayName: "NKR-5", CPU: "1", RAM: 4294967296, SortOrder: 1},
+		ReplicasPerCell: 1,
+		State:           "ready",
+		CreatedAt:       time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+		UpdatedAt:       time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+	}
+}
+
+func TestRouterListCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiRoutersService{
+		ListFn: func(_ context.Context, req *ps.ListNekiRoutersRequest) ([]*ps.NekiRouter, error) {
+			c.Assert(req, qt.DeepEquals, &ps.ListNekiRoutersRequest{
+				Organization: "acme",
+				Database:     "app",
+				Branch:       "main",
+			})
+			return []*ps.NekiRouter{testRouter()}, nil
+		},
+	}
+
+	cmd := ListCmd(routerTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.ListFnInvoked, qt.IsTrue)
+	c.Assert(out.String(), qt.JSONEquals, []map[string]interface{}{{
+		"type":                   "neki_router",
+		"name":                   "default",
+		"default":                true,
+		"sku":                    map[string]interface{}{"name": "NKR_5", "display_name": "NKR-5", "cpu": "1", "ram": float64(4294967296), "sort_order": float64(1)},
+		"replicas_per_cell":      float64(1),
+		"autoscaling":            false,
+		"max_replicas_per_cell":  nil,
+		"target_cpu_utilization": nil,
+		"state":                  "ready",
+		"created_at":             "2026-08-04T12:00:00Z",
+		"updated_at":             "2026-08-04T12:00:00Z",
+	}})
+}
+
+func TestRouterListHumanHeaders(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+
+	svc := &mock.NekiRoutersService{
+		ListFn: func(context.Context, *ps.ListNekiRoutersRequest) ([]*ps.NekiRouter, error) {
+			return []*ps.NekiRouter{testRouter()}, nil
+		},
+	}
+
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiRouters: svc}, nil
+		},
+	}
+
+	cmd := ListCmd(ch)
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "NAME")
+	c.Assert(out.String(), qt.Contains, "SIZE")
+	c.Assert(out.String(), qt.Contains, "REPLICAS PER CELL")
+	c.Assert(out.String(), qt.Contains, "AUTOSCALING")
+	c.Assert(out.String(), qt.Contains, "STATE")
+	c.Assert(out.String(), qt.Contains, "default")
+	c.Assert(out.String(), qt.Contains, "NKR-5")
+	c.Assert(out.String(), qt.Contains, "ready")
+}
+
+func TestRouterShowCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiRoutersService{
+		GetFn: func(_ context.Context, req *ps.GetNekiRouterRequest) (*ps.NekiRouter, error) {
+			c.Assert(req, qt.DeepEquals, &ps.GetNekiRouterRequest{
+				Organization: "acme",
+				Database:     "app",
+				Branch:       "main",
+				Router:       "default",
+			})
+			return testRouter(), nil
+		},
+		ListParametersFn: func(_ context.Context, req *ps.ListNekiRouterParametersRequest) ([]*ps.NekiParameter, error) {
+			c.Assert(req.Router, qt.Equals, "default")
+			return []*ps.NekiParameter{{
+				Name:          "replication-lag-tolerable-max",
+				Namespace:     "router",
+				ParameterType: "duration",
+				DefaultValue:  "10m",
+				Value:         "15m",
+			}}, nil
+		},
+	}
+
+	cmd := ShowCmd(routerTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "default"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.GetFnInvoked, qt.IsTrue)
+	c.Assert(svc.ListParametersFnInvoked, qt.IsTrue)
+	var detail map[string]interface{}
+	c.Assert(json.Unmarshal(out.Bytes(), &detail), qt.IsNil)
+	c.Assert(detail["name"], qt.Equals, "default")
+	parameters := detail["parameters"].([]interface{})
+	c.Assert(parameters, qt.HasLen, 1)
+	c.Assert(parameters[0].(map[string]interface{})["name"], qt.Equals, "replication-lag-tolerable-max")
+}
+
+func TestRouterCreateCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiRoutersService{
+		CreateFn: func(_ context.Context, req *ps.CreateNekiRouterRequest) (*ps.NekiRouter, error) {
+			c.Assert(req, qt.DeepEquals, &ps.CreateNekiRouterRequest{
+				Organization:    "acme",
+				Database:        "app",
+				Branch:          "main",
+				Name:            "analytics",
+				RouterSize:      "NKR_10",
+				ReplicasPerCell: &[]int{2}[0],
+			})
+			return &ps.NekiRouter{Name: "analytics", State: "provisioning", ReplicasPerCell: 2}, nil
+		},
+	}
+
+	cmd := CreateCmd(routerTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "analytics", "--size", "NKR-10", "--replicas-per-cell", "2"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.CreateFnInvoked, qt.IsTrue)
+	var created map[string]interface{}
+	c.Assert(json.Unmarshal(out.Bytes(), &created), qt.IsNil)
+	c.Assert(created["name"], qt.Equals, "analytics")
+	c.Assert(created["state"], qt.Equals, "provisioning")
+}
+
+func TestRouterCreateCmdDefaults(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiRoutersService{
+		CreateFn: func(_ context.Context, req *ps.CreateNekiRouterRequest) (*ps.NekiRouter, error) {
+			c.Assert(req.RouterSize, qt.Equals, "")
+			c.Assert(req.ReplicasPerCell, qt.IsNil)
+			return &ps.NekiRouter{Name: req.Name, State: "provisioning"}, nil
+		},
+	}
+
+	cmd := CreateCmd(routerTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "analytics"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+}
+
+func TestRouterUpdateCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiRoutersService{
+		UpdateFn: func(_ context.Context, req *ps.UpdateNekiRouterRequest) (*ps.NekiRouter, error) {
+			c.Assert(req.Organization, qt.Equals, "acme")
+			c.Assert(req.Router, qt.Equals, "analytics")
+			c.Assert(req.RouterSize, qt.IsNil)
+			c.Assert(req.ReplicasPerCell, qt.IsNil)
+			c.Assert(*req.Autoscaling, qt.IsTrue)
+			c.Assert(*req.MaxReplicasPerCell, qt.Equals, 4)
+			c.Assert(*req.TargetCPUUtilization, qt.Equals, 70)
+			c.Assert(req.Parameters, qt.DeepEquals, map[string]map[string]string{
+				"router": {"replication-lag-tolerable-max": "15m"},
+			})
+			return &ps.NekiRouter{Name: "analytics", State: "updating", Autoscaling: true}, nil
+		},
+	}
+
+	cmd := UpdateCmd(routerTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "analytics",
+		"--autoscaling", "--max-replicas-per-cell", "4", "--target-cpu-utilization", "70",
+		"--parameters", "router.replication-lag-tolerable-max=15m",
+	})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.UpdateFnInvoked, qt.IsTrue)
+}
+
+func TestRouterUpdateCmdRequiresFlag(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiRoutersService{}
+
+	cmd := UpdateCmd(routerTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "analytics"})
+	err := cmd.Execute()
+	c.Assert(err, qt.ErrorMatches, "at least one update flag is required")
+	c.Assert(svc.UpdateFnInvoked, qt.IsFalse)
+}
+
+func TestRouterUpdateCmdInvalidParameters(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiRoutersService{}
+
+	cmd := UpdateCmd(routerTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "analytics", "--parameters", "bogus"})
+	err := cmd.Execute()
+	c.Assert(err, qt.ErrorMatches, `invalid --parameters "bogus": expected namespace.name=value`)
+}
+
+func TestRouterDeleteCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiRoutersService{
+		DeleteFn: func(_ context.Context, req *ps.DeleteNekiRouterRequest) error {
+			c.Assert(req, qt.DeepEquals, &ps.DeleteNekiRouterRequest{
+				Organization: "acme",
+				Database:     "app",
+				Branch:       "main",
+				Router:       "analytics",
+			})
+			return nil
+		},
+	}
+
+	cmd := DeleteCmd(routerTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "analytics", "--force"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.DeleteFnInvoked, qt.IsTrue)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"result": "router deleted",
+		"router": "analytics",
+		"branch": "main",
+	})
+}
+
+func TestRouterChangesCancelCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiRoutersService{CancelChangeFn: func(_ context.Context, req *ps.CancelNekiRouterChangeRequest) error {
+		c.Assert(req, qt.DeepEquals, &ps.CancelNekiRouterChangeRequest{
+			Organization: "acme",
+			Database:     "app",
+			Branch:       "main",
+			Router:       "analytics",
+			Change:       "change-1",
+		})
+		return nil
+	}}
+
+	cmd := changesCancelCmd(routerTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "analytics", "change-1"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"result": "change canceled", "change_id": "change-1", "router": "analytics",
+	})
+}
+
+func TestRouterChangesListHumanDisplaysDifferences(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	autoscaling := true
+	maxReplicas := 4
+	targetCPU := 70
+	svc := &mock.NekiRoutersService{ListChangesFn: func(_ context.Context, req *ps.ListNekiRouterChangesRequest) ([]*ps.NekiRouterChange, error) {
+		c.Assert(req, qt.DeepEquals, &ps.ListNekiRouterChangesRequest{
+			Organization: "acme",
+			Database:     "app",
+			Branch:       "main",
+			Router:       "analytics",
+			PerPage:      100,
+		})
+		return []*ps.NekiRouterChange{{
+			ID:                            "change-1",
+			State:                         "completed",
+			CreatedAt:                     time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+			RouterSize:                    "NKR_10",
+			RouterSizeDisplayName:         "NKR-10",
+			PreviousRouterSize:            "NKR_5",
+			PreviousRouterSizeDisplayName: "NKR-5",
+			ReplicasPerCell:               2,
+			PreviousReplicasPerCell:       1,
+			Autoscaling:                   &autoscaling,
+			MaxReplicasPerCell:            &maxReplicas,
+			TargetCPUUtilization:          &targetCPU,
+			Parameters:                    map[string]map[string]string{"router": {"replication-lag-tolerable-max": "15m"}},
+			PreviousParameters:            map[string]map[string]string{"router": {"replication-lag-tolerable-max": "10m"}},
+		}}, nil
+	}}
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiRouters: svc}, nil
+		},
+	}
+
+	cmd := changesListCmd(ch)
+	cmd.SetArgs([]string{"app", "main", "analytics"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "CHANGES")
+	c.Assert(out.String(), qt.Contains, "Size: NKR-5 → NKR-10")
+	c.Assert(out.String(), qt.Contains, "Replicas per cell: 1 → 2")
+	c.Assert(out.String(), qt.Contains, "Autoscaling: (default) → true")
+	c.Assert(out.String(), qt.Contains, "Max replicas per")
+	c.Assert(out.String(), qt.Contains, "(default) → 4")
+	c.Assert(out.String(), qt.Contains, "Target CPU utilization")
+	c.Assert(out.String(), qt.Contains, "(default) → 70")
+	c.Assert(out.String(), qt.Contains, "router.replication-lag-tolerable-max: 10m → 15m")
+}
+
+func TestRouterChangesShowHumanDisplaysDifferences(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	svc := &mock.NekiRoutersService{GetChangeFn: func(_ context.Context, req *ps.GetNekiRouterChangeRequest) (*ps.NekiRouterChange, error) {
+		c.Assert(req, qt.DeepEquals, &ps.GetNekiRouterChangeRequest{
+			Organization: "acme",
+			Database:     "app",
+			Branch:       "main",
+			Router:       "analytics",
+			Change:       "change-1",
+		})
+		return &ps.NekiRouterChange{
+			ID:                      "change-1",
+			State:                   "applying",
+			CreatedAt:               time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+			RouterSize:              "NKR_10",
+			PreviousRouterSize:      "NKR_5",
+			ReplicasPerCell:         2,
+			PreviousReplicasPerCell: 1,
+			Parameters:              map[string]map[string]string{"router": {"replication-lag-tolerable-max": "15m"}},
+			PreviousParameters:      map[string]map[string]string{"router": {"replication-lag-tolerable-max": "10m"}},
+		}, nil
+	}}
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiRouters: svc}, nil
+		},
+	}
+
+	cmd := changesShowCmd(ch)
+	cmd.SetArgs([]string{"app", "main", "analytics", "change-1"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "Changes:")
+	c.Assert(out.String(), qt.Contains, "Size: NKR_5 → NKR_10")
+	c.Assert(out.String(), qt.Contains, "Replicas per cell: 1 → 2")
+	c.Assert(out.String(), qt.Contains, "Parameter router.replication-lag-tolerable-max: 10m → 15m")
+}
+
+func TestRouterSizesCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	rate := int64(25)
+	svc := &mock.NekiRoutersService{ListSizeSKUsFn: func(_ context.Context, req *ps.ListNekiRouterSizeSKUsRequest) ([]*ps.NekiRouterSKU, error) {
+		c.Assert(req, qt.DeepEquals, &ps.ListNekiRouterSizeSKUsRequest{
+			Organization: "acme",
+			Database:     "app",
+			Branch:       "main",
+			Rates:        true,
+		})
+		return []*ps.NekiRouterSKU{{
+			Name:        "NKR_5",
+			DisplayName: "NKR-5",
+			CPU:         "1",
+			RAM:         4294967296,
+			SortOrder:   1,
+			Rate:        &rate,
+		}}, nil
+	}}
+
+	cmd := SizesCmd(routerTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.ListSizeSKUsFnInvoked, qt.IsTrue)
+	c.Assert(out.String(), qt.JSONEquals, []map[string]interface{}{{
+		"name":         "NKR_5",
+		"display_name": "NKR-5",
+		"cpu":          "1",
+		"ram":          float64(4294967296),
+		"sort_order":   float64(1),
+		"rate":         float64(25),
+	}})
+}
+
+func TestRouterSizesHumanHeaders(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	rate := int64(25)
+	svc := &mock.NekiRoutersService{ListSizeSKUsFn: func(context.Context, *ps.ListNekiRouterSizeSKUsRequest) ([]*ps.NekiRouterSKU, error) {
+		return []*ps.NekiRouterSKU{{Name: "NKR_5", DisplayName: "NKR-5", CPU: "1", RAM: 4294967296, Rate: &rate}}, nil
+	}}
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiRouters: svc}, nil
+		},
+	}
+
+	cmd := SizesCmd(ch)
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "NAME")
+	c.Assert(out.String(), qt.Contains, "NKR-5")
+	c.Assert(out.String(), qt.Contains, "$25")
+}
+
+func TestRouterCmdSubcommands(t *testing.T) {
+	cmd := RouterCmd(&cmdutil.Helper{Config: &config.Config{}})
+	for _, name := range []string{"changes", "create", "delete", "list", "show", "sizes", "update"} {
+		found, _, err := cmd.Find([]string{name})
+		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, found.Name(), qt.Equals, name)
+	}
+
+	changes, _, err := cmd.Find([]string{"changes"})
+	qt.Assert(t, err, qt.IsNil)
+	for _, name := range []string{"cancel", "list", "show"} {
+		found, _, err := changes.Find([]string{name})
+		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, found.Name(), qt.Equals, name)
+	}
+}
diff --git a/internal/cmd/router/show.go b/internal/cmd/router/show.go
new file mode 100644
index 000000000..3c98dc2f9
--- /dev/null
+++ b/internal/cmd/router/show.go
@@ -0,0 +1,65 @@
+package router
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ShowCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "show <database> <branch> <name>",
+		Short:   "Show a router for a Neki database branch",
+		Args:    cmdutil.ExactArgs("database", "branch", "name"),
+		Aliases: []string{"get"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching router %s", printer.BoldBlue(name)))
+			defer end()
+
+			router, err := client.NekiRouters.Get(cmd.Context(), &ps.GetNekiRouterRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Router:       name,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+
+			parameters, err := client.NekiRouters.ListParameters(cmd.Context(), &ps.ListNekiRouterParametersRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Router:       name,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+
+			if ch.Printer.Format() != printer.Human {
+				return ch.Printer.PrintResource(toRouterDetail(router, parameters))
+			}
+
+			if err := ch.Printer.PrintResource(toRouter(router)); err != nil {
+				return err
+			}
+			if len(parameters) == 0 {
+				return nil
+			}
+			ch.Printer.Println()
+			return ch.Printer.PrintResource(toParameters(parameters))
+		},
+	}
+
+	return cmd
+}
diff --git a/internal/cmd/router/sizes.go b/internal/cmd/router/sizes.go
new file mode 100644
index 000000000..8f03be91d
--- /dev/null
+++ b/internal/cmd/router/sizes.go
@@ -0,0 +1,90 @@
+package router
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func SizesCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "sizes <database> <branch>",
+		Short:   "List available router sizes for a Neki database branch",
+		Args:    cmdutil.ExactArgs("database", "branch"),
+		Aliases: []string{"size-skus"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching router sizes for %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			skus, err := client.NekiRouters.ListSizeSKUs(cmd.Context(), &ps.ListNekiRouterSizeSKUsRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Rates:        true,
+			})
+			if err != nil {
+				return handleError(err, database, branch, "")
+			}
+			end()
+
+			if len(skus) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No router sizes found for %s/%s.\n", printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(toRouterSKUs(skus))
+		},
+	}
+
+	return cmd
+}
+
+type routerSKUDisplay struct {
+	Name   string `header:"name" json:"name"`
+	CPU    string `header:"cpu" json:"cpu"`
+	Memory string `header:"memory" json:"memory"`
+	Cost   string `header:"cost" json:"rate"`
+
+	orig *ps.NekiRouterSKU
+}
+
+func (s *routerSKUDisplay) MarshalJSON() ([]byte, error) { return json.Marshal(s.orig) }
+func (s *routerSKUDisplay) MarshalCSVValue() interface{} { return []*routerSKUDisplay{s} }
+
+func toRouterSKU(sku *ps.NekiRouterSKU) *routerSKUDisplay {
+	name := sku.DisplayName
+	if name == "" {
+		name = cmdutil.ToClusterSizeSlug(sku.Name)
+	}
+
+	cost := ""
+	if sku.Rate != nil && *sku.Rate > 0 {
+		cost = fmt.Sprintf("$%d", *sku.Rate)
+	}
+
+	return &routerSKUDisplay{
+		Name:   name,
+		CPU:    sku.CPU,
+		Memory: cmdutil.FormatParts(sku.RAM).IntString(),
+		Cost:   cost,
+		orig:   sku,
+	}
+}
+
+func toRouterSKUs(skus []*ps.NekiRouterSKU) []*routerSKUDisplay {
+	out := make([]*routerSKUDisplay, 0, len(skus))
+	for _, sku := range skus {
+		out = append(out, toRouterSKU(sku))
+	}
+	return out
+}
diff --git a/internal/cmd/router/update.go b/internal/cmd/router/update.go
new file mode 100644
index 000000000..c9e62641c
--- /dev/null
+++ b/internal/cmd/router/update.go
@@ -0,0 +1,124 @@
+package router
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func UpdateCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		size                 string
+		replicasPerCell      int
+		autoscaling          bool
+		maxReplicasPerCell   int
+		targetCPUUtilization int
+		parameters           []string
+	}
+
+	cmd := &cobra.Command{
+		Use:   "update <database> <branch> <name>",
+		Short: "Update a router for a Neki database branch",
+		Long:  "Update a router for a Neki database branch.\n\nChanges are requested and applied asynchronously; the router state shows progress.",
+		Args:  cmdutil.ExactArgs("database", "branch", "name"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, name := args[0], args[1], args[2]
+
+			changed := false
+			for _, flag := range []string{"size", "replicas-per-cell", "autoscaling", "max-replicas-per-cell", "target-cpu-utilization", "parameters"} {
+				changed = changed || cmd.Flags().Changed(flag)
+			}
+			if !changed {
+				return fmt.Errorf("at least one update flag is required")
+			}
+
+			parameters, err := parseParameters(flags.parameters)
+			if err != nil {
+				return err
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Updating router %s", printer.BoldBlue(name)))
+			defer end()
+
+			router, err := client.NekiRouters.Update(cmd.Context(), &ps.UpdateNekiRouterRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				Router:               name,
+				RouterSize:           stringPointerIfChanged(cmd, "size", cmdutil.ToSizeSKUName(flags.size)),
+				ReplicasPerCell:      intPointerIfChanged(cmd, "replicas-per-cell", flags.replicasPerCell),
+				Autoscaling:          boolPointerIfChanged(cmd, "autoscaling", flags.autoscaling),
+				MaxReplicasPerCell:   intPointerIfChanged(cmd, "max-replicas-per-cell", flags.maxReplicasPerCell),
+				TargetCPUUtilization: intPointerIfChanged(cmd, "target-cpu-utilization", flags.targetCPUUtilization),
+				Parameters:           parameters,
+			})
+			if err != nil {
+				return handleError(err, database, branch, name)
+			}
+			end()
+
+			return ch.Printer.PrintResource(toRouter(router))
+		},
+	}
+
+	cmd.Flags().StringVar(&flags.size, "size", "", "New router size SKU (e.g. NKR-5)")
+	cmd.Flags().IntVar(&flags.replicasPerCell, "replicas-per-cell", 0, "New number of replicas in each cell")
+	cmd.Flags().BoolVar(&flags.autoscaling, "autoscaling", false, "Whether the router scales horizontally within each cell")
+	cmd.Flags().IntVar(&flags.maxReplicasPerCell, "max-replicas-per-cell", 0, "Maximum number of replicas in each cell when autoscaling")
+	cmd.Flags().IntVar(&flags.targetCPUUtilization, "target-cpu-utilization", 0, "Target average CPU utilization percentage when autoscaling")
+	cmd.Flags().StringArrayVar(&flags.parameters, "parameters", nil, "Set a parameter as namespace.name=value; repeatable")
+
+	return cmd
+}
+
+func parseParameters(values []string) (map[string]map[string]string, error) {
+	if len(values) == 0 {
+		return nil, nil
+	}
+	out := make(map[string]map[string]string)
+	for _, value := range values {
+		key, setting, ok := strings.Cut(value, "=")
+		if !ok {
+			return nil, fmt.Errorf("invalid --parameters %q: expected namespace.name=value", value)
+		}
+		namespace, name, ok := strings.Cut(key, ".")
+		if !ok || namespace == "" || name == "" {
+			return nil, fmt.Errorf("invalid --parameters %q: expected namespace.name=value", value)
+		}
+		if out[namespace] == nil {
+			out[namespace] = make(map[string]string)
+		}
+		out[namespace][name] = setting
+	}
+	return out, nil
+}
+
+func stringPointerIfChanged(cmd *cobra.Command, name, value string) *string {
+	if !cmd.Flags().Changed(name) {
+		return nil
+	}
+	return &value
+}
+
+func intPointerIfChanged(cmd *cobra.Command, name string, value int) *int {
+	if !cmd.Flags().Changed(name) {
+		return nil
+	}
+	return &value
+}
+
+func boolPointerIfChanged(cmd *cobra.Command, name string, value bool) *bool {
+	if !cmd.Flags().Changed(name) {
+		return nil
+	}
+	return &value
+}
diff --git a/internal/cmd/shard/assign.go b/internal/cmd/shard/assign.go
new file mode 100644
index 000000000..66b586ee1
--- /dev/null
+++ b/internal/cmd/shard/assign.go
@@ -0,0 +1,51 @@
+package shard
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func AssignCmd(ch *cmdutil.Helper) *cobra.Command {
+	var configurationProfile string
+
+	cmd := &cobra.Command{
+		Use:   "assign <database> <branch> <shard-id>...",
+		Short: "Assign shards to a Neki configuration profile",
+		Args:  cmdutil.RequiredArgs("database", "branch", "shard-id"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			shardIDs := args[2:]
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Assigning %d shard(s) to configuration profile %s", len(shardIDs), printer.BoldBlue(configurationProfile)))
+			defer end()
+
+			assignments, err := client.NekiShards.Assign(cmd.Context(), &ps.AssignNekiShardsRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: configurationProfile,
+				ShardIDs:             shardIDs,
+			})
+			if err != nil {
+				return handleError(err, database, branch, "", configurationProfile)
+			}
+			end()
+
+			return ch.Printer.PrintResource(toShardAssignments(assignments))
+		},
+	}
+
+	cmd.Flags().StringVar(&configurationProfile, "config-profile", "", "Configuration profile to assign the shards to")
+	cmd.MarkFlagRequired("config-profile") // nolint:errcheck
+
+	return cmd
+}
diff --git a/internal/cmd/shard/create.go b/internal/cmd/shard/create.go
new file mode 100644
index 000000000..f8a641148
--- /dev/null
+++ b/internal/cmd/shard/create.go
@@ -0,0 +1,60 @@
+package shard
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func CreateCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		configurationProfile string
+		count                int
+	}
+
+	cmd := &cobra.Command{
+		Use:   "create <database> <branch>",
+		Short: "Create shards in a Neki configuration profile",
+		Args:  cmdutil.ExactArgs("database", "branch"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			if flags.count < 1 {
+				return fmt.Errorf("--count must be greater than 0")
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Creating %d shard(s) in configuration profile %s", flags.count, printer.BoldBlue(flags.configurationProfile)))
+			defer end()
+
+			response, err := client.NekiShards.Create(cmd.Context(), &ps.CreateNekiShardsRequest{
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				ConfigurationProfile: flags.configurationProfile,
+				Count:                flags.count,
+			})
+			if err != nil {
+				return handleError(err, database, branch, "", flags.configurationProfile)
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Created %d shard(s) in configuration profile %s.\n", response.Created, printer.BoldBlue(flags.configurationProfile))
+			}
+			return ch.Printer.PrintResource(toShardCreation(response))
+		},
+	}
+
+	cmd.Flags().StringVar(&flags.configurationProfile, "config-profile", "", "Configuration profile that will host the new shards")
+	cmd.Flags().IntVar(&flags.count, "count", 1, "Number of shards to create")
+	cmd.MarkFlagRequired("config-profile") // nolint:errcheck
+
+	return cmd
+}
diff --git a/internal/cmd/shard/delete.go b/internal/cmd/shard/delete.go
new file mode 100644
index 000000000..ed8d27904
--- /dev/null
+++ b/internal/cmd/shard/delete.go
@@ -0,0 +1,63 @@
+package shard
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func DeleteCmd(ch *cmdutil.Helper) *cobra.Command {
+	var force bool
+
+	cmd := &cobra.Command{
+		Use:     "delete <database> <branch> <shard-id>",
+		Short:   "Delete a shard from a Neki database branch",
+		Args:    cmdutil.ExactArgs("database", "branch", "shard-id"),
+		Aliases: []string{"rm"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, shardID := args[0], args[1], args[2]
+			if !force {
+				confirmationName := fmt.Sprintf("%s/%s/%s", database, branch, shardID)
+				if err := ch.Printer.ConfirmCommand(confirmationName, "delete shard", "deletion of shard"); err != nil {
+					return err
+				}
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Deleting shard %s from %s/%s", printer.BoldBlue(shardID), printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			err = client.NekiShards.Delete(cmd.Context(), &ps.DeleteNekiShardRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Shard:        shardID,
+			})
+			if err != nil {
+				return handleError(err, database, branch, shardID, "")
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Shard %s was successfully deleted from %s/%s.\n", printer.BoldBlue(shardID), printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(map[string]string{
+				"result":   "shard deleted",
+				"shard_id": shardID,
+				"branch":   branch,
+			})
+		},
+	}
+
+	cmd.Flags().BoolVar(&force, "force", false, "Delete the shard without confirmation")
+	return cmd
+}
diff --git a/internal/cmd/shard/errors.go b/internal/cmd/shard/errors.go
new file mode 100644
index 000000000..991e766f0
--- /dev/null
+++ b/internal/cmd/shard/errors.go
@@ -0,0 +1,28 @@
+package shard
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+func handleError(err error, database, branch, shardID, configurationProfile string) error {
+	if cmdutil.ErrCode(err) != ps.ErrNotFound {
+		return cmdutil.HandleError(err)
+	}
+
+	if shardID != "" {
+		return fmt.Errorf("shard %s does not exist in branch %s of database %s",
+			printer.BoldBlue(shardID), printer.BoldBlue(branch), printer.BoldBlue(database))
+	}
+
+	if configurationProfile != "" {
+		return fmt.Errorf("database %s, branch %s, or configuration profile %s does not exist, or the branch is not a Neki branch",
+			printer.BoldBlue(database), printer.BoldBlue(branch), printer.BoldBlue(configurationProfile))
+	}
+
+	return fmt.Errorf("database %s or branch %s does not exist, or the branch is not a Neki branch",
+		printer.BoldBlue(database), printer.BoldBlue(branch))
+}
diff --git a/internal/cmd/shard/list.go b/internal/cmd/shard/list.go
new file mode 100644
index 000000000..d352463b8
--- /dev/null
+++ b/internal/cmd/shard/list.go
@@ -0,0 +1,68 @@
+package shard
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ListCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		configurationProfile        string
+		excludeConfigurationProfile string
+		query                       string
+		page                        int
+		perPage                     int
+	}
+
+	cmd := &cobra.Command{
+		Use:     "list <database> <branch>",
+		Short:   "List shards for a Neki database branch",
+		Args:    cmdutil.ExactArgs("database", "branch"),
+		Aliases: []string{"ls"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching shards for %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			shards, err := client.NekiShards.List(cmd.Context(), &ps.ListNekiShardsRequest{
+				Organization:                ch.Config.Organization,
+				Database:                    database,
+				Branch:                      branch,
+				ConfigurationProfile:        flags.configurationProfile,
+				ExcludeConfigurationProfile: flags.excludeConfigurationProfile,
+				Query:                       flags.query,
+				Page:                        flags.page,
+				PerPage:                     flags.perPage,
+			})
+			if err != nil {
+				return handleError(err, database, branch, "", flags.configurationProfile)
+			}
+			end()
+
+			if len(shards) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No shards found in %s/%s.\n", printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(toShards(shards))
+		},
+	}
+
+	cmd.Flags().StringVar(&flags.configurationProfile, "config-profile", "", "List shards assigned to this configuration profile")
+	cmd.Flags().StringVar(&flags.excludeConfigurationProfile, "exclude-config-profile", "", "Exclude shards assigned to this configuration profile")
+	cmd.Flags().StringVarP(&flags.query, "query", "q", "", "Search by shard name, display name, or configuration profile")
+	cmd.Flags().IntVar(&flags.page, "page", 0, "Page number to fetch")
+	cmd.Flags().IntVar(&flags.perPage, "per-page", 100, "Number of results per page")
+	cmd.MarkFlagsMutuallyExclusive("config-profile", "exclude-config-profile")
+
+	return cmd
+}
diff --git a/internal/cmd/shard/shard.go b/internal/cmd/shard/shard.go
new file mode 100644
index 000000000..da7a24b08
--- /dev/null
+++ b/internal/cmd/shard/shard.go
@@ -0,0 +1,130 @@
+package shard
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/spf13/cobra"
+)
+
+func ShardCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "shard <command>",
+		Short: "Manage shards for a Neki database branch",
+		Long:  "Manage shards for a Neki database branch.\n\nThis command is only supported for Neki databases.",
+	}
+
+	cmd.AddCommand(
+		AssignCmd(ch),
+		CreateCmd(ch),
+		DeleteCmd(ch),
+		ListCmd(ch),
+		ShowCmd(ch),
+		UpdateCmd(ch),
+	)
+
+	return cmd
+}
+
+type shardDisplay struct {
+	ID                   string `header:"id" json:"id"`
+	Name                 string `header:"name" json:"name"`
+	DisplayName          string `header:"display name" json:"display_name"`
+	ConfigurationProfile string `header:"configuration profile" json:"configuration_profile"`
+	Ready                bool   `header:"ready" json:"ready"`
+	Authoritative        bool   `header:"authoritative" json:"authoritative"`
+	CreatedAt            string `header:"created at" json:"created_at"`
+
+	orig *ps.NekiShard
+}
+
+func (s *shardDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.orig)
+}
+
+func (s *shardDisplay) MarshalCSVValue() interface{} {
+	return []*shardDisplay{s}
+}
+
+func toShard(shard *ps.NekiShard) *shardDisplay {
+	displayName := ""
+	if shard.DisplayName != nil {
+		displayName = *shard.DisplayName
+	}
+
+	return &shardDisplay{
+		ID:                   shard.ID,
+		Name:                 shard.Name,
+		DisplayName:          displayName,
+		ConfigurationProfile: shard.ConfigurationProfile,
+		Ready:                shard.Ready,
+		Authoritative:        shard.Authoritative,
+		CreatedAt:            shard.CreatedAt.UTC().Format("2006-01-02 15:04:05"),
+		orig:                 shard,
+	}
+}
+
+func toShards(shards []*ps.NekiShard) []*shardDisplay {
+	result := make([]*shardDisplay, 0, len(shards))
+	for _, shard := range shards {
+		result = append(result, toShard(shard))
+	}
+	return result
+}
+
+type shardCreationDisplay struct {
+	Created  int    `header:"created" json:"created"`
+	ShardIDs string `header:"shard ids" json:"shard_ids"`
+
+	orig *ps.CreateNekiShardsResponse
+}
+
+func (s *shardCreationDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.orig)
+}
+
+func (s *shardCreationDisplay) MarshalCSVValue() interface{} {
+	return []*shardCreationDisplay{s}
+}
+
+func toShardCreation(response *ps.CreateNekiShardsResponse) *shardCreationDisplay {
+	return &shardCreationDisplay{
+		Created:  response.Created,
+		ShardIDs: strings.Join(response.ShardIDs, ", "),
+		orig:     response,
+	}
+}
+
+type shardAssignmentDisplay struct {
+	ID     string `header:"id" json:"id"`
+	Status string `header:"status" json:"status"`
+	Error  string `header:"error" json:"error,omitempty"`
+
+	orig *ps.NekiShardAssignment
+}
+
+func (s *shardAssignmentDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.orig)
+}
+
+func toShardAssignments(assignments []*ps.NekiShardAssignment) []*shardAssignmentDisplay {
+	result := make([]*shardAssignmentDisplay, 0, len(assignments))
+	for _, assignment := range assignments {
+		errorText := ""
+		if assignment.Error != nil {
+			encoded, err := json.Marshal(assignment.Error)
+			if err == nil {
+				errorText = string(encoded)
+			}
+		}
+		result = append(result, &shardAssignmentDisplay{
+			ID:     assignment.ID,
+			Status: assignment.Status,
+			Error:  errorText,
+			orig:   assignment,
+		})
+	}
+	return result
+}
diff --git a/internal/cmd/shard/shard_test.go b/internal/cmd/shard/shard_test.go
new file mode 100644
index 000000000..099c78ca6
--- /dev/null
+++ b/internal/cmd/shard/shard_test.go
@@ -0,0 +1,287 @@
+package shard
+
+import (
+	"bytes"
+	"context"
+	"testing"
+	"time"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/config"
+	"github.com/planetscale/cli/internal/mock"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func shardTestHelper(svc ps.NekiShardsService, out *bytes.Buffer) *cmdutil.Helper {
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(out)
+	return &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiShards: svc}, nil
+		},
+	}
+}
+
+func TestShardListCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	displayName := "reports"
+	svc := &mock.NekiShardsService{
+		ListFn: func(_ context.Context, req *ps.ListNekiShardsRequest) ([]*ps.NekiShard, error) {
+			c.Assert(req, qt.DeepEquals, &ps.ListNekiShardsRequest{
+				Organization:         "acme",
+				Database:             "app",
+				Branch:               "main",
+				ConfigurationProfile: "analytics",
+				Query:                "report",
+				Page:                 2,
+				PerPage:              20,
+			})
+			return []*ps.NekiShard{{
+				ID:                   "shard-1",
+				Name:                 "0",
+				DisplayName:          &displayName,
+				ConfigurationProfile: "analytics",
+				Ready:                true,
+				Authoritative:        true,
+				CreatedAt:            time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+			}}, nil
+		},
+	}
+
+	cmd := ListCmd(shardTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "--config-profile", "analytics", "--query", "report", "--page", "2", "--per-page", "20"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.ListFnInvoked, qt.IsTrue)
+	c.Assert(out.String(), qt.JSONEquals, []map[string]interface{}{{
+		"id":                    "shard-1",
+		"name":                  "0",
+		"display_name":          "reports",
+		"configuration_profile": "analytics",
+		"ready":                 true,
+		"authoritative":         true,
+		"created_at":            "2026-08-04T12:00:00Z",
+	}})
+}
+
+func TestShardListHumanHeaders(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+
+	svc := &mock.NekiShardsService{
+		ListFn: func(context.Context, *ps.ListNekiShardsRequest) ([]*ps.NekiShard, error) {
+			return []*ps.NekiShard{{
+				ID:                   "shard-1",
+				Name:                 "0",
+				ConfigurationProfile: "default",
+				Ready:                true,
+				Authoritative:        true,
+				CreatedAt:            time.Date(2026, 8, 4, 12, 0, 0, 0, time.FixedZone("MDT", -6*60*60)),
+			}}, nil
+		},
+	}
+
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiShards: svc}, nil
+		},
+	}
+
+	cmd := ListCmd(ch)
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "DISPLAY NAME")
+	c.Assert(out.String(), qt.Contains, "CONFIGURATION PROFILE")
+	c.Assert(out.String(), qt.Contains, "READY")
+	c.Assert(out.String(), qt.Contains, "AUTHORITATIVE")
+	c.Assert(out.String(), qt.Contains, "CREATED AT")
+	c.Assert(out.String(), qt.Contains, "Yes")
+	c.Assert(out.String(), qt.Contains, "2026-08-04 18:00:00")
+}
+
+func TestShardCreateCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardsService{
+		CreateFn: func(_ context.Context, req *ps.CreateNekiShardsRequest) (*ps.CreateNekiShardsResponse, error) {
+			c.Assert(req, qt.DeepEquals, &ps.CreateNekiShardsRequest{
+				Organization:         "acme",
+				Database:             "app",
+				Branch:               "main",
+				ConfigurationProfile: "analytics",
+				Count:                2,
+			})
+			return &ps.CreateNekiShardsResponse{Created: 2, ShardIDs: []string{"shard-1", "shard-2"}}, nil
+		},
+	}
+
+	cmd := CreateCmd(shardTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "--config-profile", "analytics", "--count", "2"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"created":   2,
+		"shard_ids": []interface{}{"shard-1", "shard-2"},
+	})
+}
+
+func TestShardAssignCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardsService{
+		AssignFn: func(_ context.Context, req *ps.AssignNekiShardsRequest) ([]*ps.NekiShardAssignment, error) {
+			c.Assert(req, qt.DeepEquals, &ps.AssignNekiShardsRequest{
+				Organization:         "acme",
+				Database:             "app",
+				Branch:               "main",
+				ConfigurationProfile: "analytics",
+				ShardIDs:             []string{"shard-1", "shard-2"},
+			})
+			return []*ps.NekiShardAssignment{
+				{ID: "shard-1", Status: "assigned"},
+				{ID: "shard-2", Status: "failed", Error: map[string]interface{}{"code": "incompatible_architecture"}},
+			}, nil
+		},
+	}
+
+	cmd := AssignCmd(shardTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "shard-1", "shard-2", "--config-profile", "analytics"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, []map[string]interface{}{
+		{"id": "shard-1", "status": "assigned"},
+		{"id": "shard-2", "status": "failed", "error": map[string]interface{}{"code": "incompatible_architecture"}},
+	})
+}
+
+func TestShardUpdateCmdCanClearDisplayName(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardsService{
+		UpdateFn: func(_ context.Context, req *ps.UpdateNekiShardRequest) (*ps.NekiShard, error) {
+			c.Assert(req.DisplayName, qt.IsNil)
+			return &ps.NekiShard{ID: req.Shard, Name: "0", DisplayName: req.DisplayName, ConfigurationProfile: "default"}, nil
+		},
+	}
+
+	cmd := UpdateCmd(shardTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "shard-1", "--display-name="})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"id":                    "shard-1",
+		"name":                  "0",
+		"display_name":          nil,
+		"configuration_profile": "default",
+		"ready":                 false,
+		"authoritative":         false,
+		"created_at":            "0001-01-01T00:00:00Z",
+	})
+}
+
+func TestShardUpdateCmdPreservesDisplayName(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardsService{
+		UpdateFn: func(_ context.Context, req *ps.UpdateNekiShardRequest) (*ps.NekiShard, error) {
+			c.Assert(req.DisplayName, qt.IsNotNil)
+			c.Assert(*req.DisplayName, qt.Equals, "reporting")
+			return &ps.NekiShard{ID: req.Shard, Name: "0", DisplayName: req.DisplayName, ConfigurationProfile: "default"}, nil
+		},
+	}
+
+	cmd := UpdateCmd(shardTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "shard-1", "--display-name=reporting"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"id":                    "shard-1",
+		"name":                  "0",
+		"display_name":          "reporting",
+		"configuration_profile": "default",
+		"ready":                 false,
+		"authoritative":         false,
+		"created_at":            "0001-01-01T00:00:00Z",
+	})
+}
+
+func TestShardShowCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	displayName := "reports"
+	svc := &mock.NekiShardsService{
+		GetFn: func(_ context.Context, req *ps.GetNekiShardRequest) (*ps.NekiShard, error) {
+			c.Assert(req, qt.DeepEquals, &ps.GetNekiShardRequest{
+				Organization: "acme",
+				Database:     "app",
+				Branch:       "main",
+				Shard:        "shard-1",
+			})
+			return &ps.NekiShard{
+				ID:                   "shard-1",
+				Name:                 "0",
+				DisplayName:          &displayName,
+				ConfigurationProfile: "analytics",
+				Ready:                true,
+				Authoritative:        true,
+				CreatedAt:            time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+			}, nil
+		},
+	}
+
+	cmd := ShowCmd(shardTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "shard-1"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.GetFnInvoked, qt.IsTrue)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"id":                    "shard-1",
+		"name":                  "0",
+		"display_name":          "reports",
+		"configuration_profile": "analytics",
+		"ready":                 true,
+		"authoritative":         true,
+		"created_at":            "2026-08-04T12:00:00Z",
+	})
+}
+
+func TestShardDeleteCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiShardsService{
+		DeleteFn: func(_ context.Context, req *ps.DeleteNekiShardRequest) error {
+			c.Assert(req, qt.DeepEquals, &ps.DeleteNekiShardRequest{
+				Organization: "acme",
+				Database:     "app",
+				Branch:       "main",
+				Shard:        "shard-1",
+			})
+			return nil
+		},
+	}
+
+	cmd := DeleteCmd(shardTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "shard-1", "--force"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"result":   "shard deleted",
+		"shard_id": "shard-1",
+		"branch":   "main",
+	})
+}
+
+func TestShardCmdSubcommands(t *testing.T) {
+	cmd := ShardCmd(&cmdutil.Helper{Config: &config.Config{}})
+	for _, name := range []string{"assign", "create", "delete", "list", "show", "update"} {
+		found, _, err := cmd.Find([]string{name})
+		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, found.Name(), qt.Equals, name)
+	}
+}
diff --git a/internal/cmd/shard/show.go b/internal/cmd/shard/show.go
new file mode 100644
index 000000000..4db93dbc6
--- /dev/null
+++ b/internal/cmd/shard/show.go
@@ -0,0 +1,44 @@
+package shard
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ShowCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "show <database> <branch> <shard-id>",
+		Short:   "Show a shard for a Neki database branch",
+		Args:    cmdutil.ExactArgs("database", "branch", "shard-id"),
+		Aliases: []string{"get"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, shardID := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching shard %s", printer.BoldBlue(shardID)))
+			defer end()
+
+			shard, err := client.NekiShards.Get(cmd.Context(), &ps.GetNekiShardRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Shard:        shardID,
+			})
+			if err != nil {
+				return handleError(err, database, branch, shardID, "")
+			}
+			end()
+
+			return ch.Printer.PrintResource(toShard(shard))
+		},
+	}
+
+	return cmd
+}
diff --git a/internal/cmd/shard/update.go b/internal/cmd/shard/update.go
new file mode 100644
index 000000000..307e2564f
--- /dev/null
+++ b/internal/cmd/shard/update.go
@@ -0,0 +1,61 @@
+package shard
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func UpdateCmd(ch *cmdutil.Helper) *cobra.Command {
+	var displayName string
+
+	cmd := &cobra.Command{
+		Use:   "update <database> <branch> <shard-id>",
+		Short: "Update a Neki shard's display name",
+		Args:  cmdutil.ExactArgs("database", "branch", "shard-id"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, shardID := args[0], args[1], args[2]
+			if !cmd.Flags().Changed("display-name") {
+				return fmt.Errorf("--display-name flag is required")
+			}
+
+			var displayNameValue *string
+			if displayName != "" {
+				displayNameValue = &displayName
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Updating shard %s in %s/%s", printer.BoldBlue(shardID), printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			shard, err := client.NekiShards.Update(cmd.Context(), &ps.UpdateNekiShardRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Shard:        shardID,
+				DisplayName:  displayNameValue,
+			})
+			if err != nil {
+				return handleError(err, database, branch, shardID, "")
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Shard %s was successfully updated.\n", printer.BoldBlue(shardID))
+			}
+			return ch.Printer.PrintResource(toShard(shard))
+		},
+	}
+
+	cmd.Flags().StringVar(&displayName, "display-name", "", "New display name; pass an empty string to clear it")
+	cmd.MarkFlagRequired("display-name") // nolint:errcheck
+
+	return cmd
+}
diff --git a/internal/cmd/shell/shell.go b/internal/cmd/shell/shell.go
index 6b83ca6b6..5988900ef 100644
--- a/internal/cmd/shell/shell.go
+++ b/internal/cmd/shell/shell.go
@@ -30,6 +30,7 @@ type shellFlags struct {
 	dbName     string
 	role       string
 	replica    bool
+	router     string
 }
 
 func ShellCmd(ch *cmdutil.Helper, sigc chan os.Signal, signals ...os.Signal) *cobra.Command {
@@ -115,14 +116,14 @@ to connect to using --db-name (or as a third argument):
 				if err != nil {
 					return err
 				}
-			case "postgresql", "horizon":
+			case "postgresql", "horizon", "neki":
 				clientPath, err = cmdutil.PostgreSQLClientPath()
 				if err != nil {
 					return err
 				}
 				isPostgreSQL = true
 			default:
-				return fmt.Errorf("unsupported database kind: %s. Only 'mysql' and 'postgresql' are supported", dbInfo.Kind)
+				return fmt.Errorf("unsupported database kind: %s. Only 'mysql', 'postgresql', and 'neki' are supported", dbInfo.Kind)
 			}
 
 			var branch string
@@ -191,7 +192,7 @@ to connect to using --db-name (or as a third argument):
 					dbName = dbNamePositional
 				}
 
-				return startShellForPostgres(ctx, ch, client, database, branch, dbBranch, clientPath, role, flags, dbName, sigc, signals, runForeground)
+				return startShellForPostgres(ctx, ch, client, database, branch, dbBranch, dbInfo.Kind, clientPath, role, flags, dbName, sigc, signals, runForeground)
 			}
 
 			if flags.dbName != "" || dbNamePositional != "" {
@@ -210,6 +211,7 @@ to connect to using --db-name (or as a third argument):
 	cmd.PersistentFlags().StringVar(&flags.role, "role",
 		"", "Role defines the access level, allowed values are: reader, writer, readwriter, admin. Defaults to 'reader' for replica passwords, otherwise defaults to 'admin'.")
 	cmd.Flags().BoolVar(&flags.replica, "replica", false, "When enabled, the password will route all reads to the branch's primary replicas and all read-only regions.")
+	cmd.Flags().StringVar(&flags.router, "router", "", "Connect through the named router group. Only supported for Neki databases.")
 	cmd.Flags().StringVar(&flags.dbName, "db-name", "",
 		"Postgres logical database name to connect to (default: postgres). Only supported for Postgres databases.")
 
@@ -235,6 +237,7 @@ type postgresql struct {
 	debug        bool
 	printer      *printer.Printer
 	password     string
+	pgOptions    string
 }
 
 // Run runs the `mysql` client with the given arguments.
@@ -276,6 +279,9 @@ func (p *postgresql) Run(ctx context.Context, sigc chan os.Signal, signals []os.
 		fmt.Sprintf("PSQL_HISTORY=%s", p.historyFile),
 		fmt.Sprintf("PGPASSWORD=%s", p.password),
 	)
+	if p.pgOptions != "" {
+		c.Env = append(c.Env, fmt.Sprintf("PGOPTIONS=%s", p.pgOptions))
+	}
 
 	c.Stdout = os.Stdout
 	c.Stderr = os.Stderr
@@ -292,6 +298,33 @@ func (p *postgresql) Run(ctx context.Context, sigc chan os.Signal, signals []os.
 	return c.Run()
 }
 
+// shellUsername applies routing suffixes to the role username. Neki branches
+// select router groups with a |<name> suffix; replica reads on Neki use
+// PGOPTIONS (see shellPgOptions) instead of the |replica suffix.
+func shellUsername(username string, replica bool, router string, kind ps.DatabaseEngine) (string, error) {
+	if router != "" && kind != ps.DatabaseEngineNeki {
+		return "", errors.New("--router is only supported for Neki databases")
+	}
+	if replica && kind != ps.DatabaseEngineNeki {
+		username += "|replica"
+	}
+	if router != "" {
+		username += "|" + router
+	}
+	return username, nil
+}
+
+// nekiReplicaOptions routes a Neki connection to replicas via the psql
+// PGOPTIONS environment variable.
+const nekiReplicaOptions = "-c __neki.target=REPLICA"
+
+func shellPgOptions(replica bool, kind ps.DatabaseEngine) string {
+	if replica && kind == ps.DatabaseEngineNeki {
+		return nekiReplicaOptions
+	}
+	return ""
+}
+
 func formatBranch(database string, branch *ps.DatabaseBranch) string {
 	branchStr := branch.Name
 
@@ -338,7 +371,7 @@ func historyFilePath(org, db, branch string) string {
 	return historyFile
 }
 
-func startShellForPostgres(ctx context.Context, ch *cmdutil.Helper, client *ps.Client, database, branch string, dbBranch *ps.DatabaseBranch, clientPath string, role cmdutil.PasswordRole, flags shellFlags, dbName string, sigc chan os.Signal, signals []os.Signal, runForeground bool) error {
+func startShellForPostgres(ctx context.Context, ch *cmdutil.Helper, client *ps.Client, database, branch string, dbBranch *ps.DatabaseBranch, kind ps.DatabaseEngine, clientPath string, role cmdutil.PasswordRole, flags shellFlags, dbName string, sigc chan os.Signal, signals []os.Signal, runForeground bool) error {
 	// Postgres connects directly, no local proxy needed
 	if flags.localAddr != "" {
 		return errors.New("--local-addr flag is not supported for Postgres databases")
@@ -360,12 +393,6 @@ func startShellForPostgres(ctx context.Context, ch *cmdutil.Helper, client *ps.C
 		return cmdutil.HandleError(err)
 	}
 
-	username := pgRole.Role.Username
-	if flags.replica {
-		username = username + "|replica"
-	}
-	password := pgRole.Role.Password
-
 	defer func() {
 		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
@@ -375,6 +402,21 @@ func startShellForPostgres(ctx context.Context, ch *cmdutil.Helper, client *ps.C
 		}
 	}()
 
+	if !pgRole.Role.Ready {
+		end := ch.Printer.PrintProgress("Waiting for role to become ready...")
+		err = pgRole.WaitUntilReady(ctx)
+		end()
+		if err != nil {
+			return cmdutil.HandleError(err)
+		}
+	}
+
+	username, err := shellUsername(pgRole.Role.Username, flags.replica, flags.router, kind)
+	if err != nil {
+		return err
+	}
+	password := pgRole.Role.Password
+
 	remoteAddr := flags.remoteAddr
 	if remoteAddr == "" {
 		remoteAddr = pgRole.Role.AccessHostURL
@@ -405,6 +447,7 @@ func startShellForPostgres(ctx context.Context, ch *cmdutil.Helper, client *ps.C
 		debug:        ch.Debug(),
 		printer:      ch.Printer,
 		password:     password,
+		pgOptions:    shellPgOptions(flags.replica, kind),
 	}
 
 	err = psql.Run(ctx, sigc, signals, runForeground, psqlArgs...)
diff --git a/internal/cmd/shell/shell_test.go b/internal/cmd/shell/shell_test.go
index 8bbb5c3da..4d8641777 100644
--- a/internal/cmd/shell/shell_test.go
+++ b/internal/cmd/shell/shell_test.go
@@ -3,9 +3,47 @@ package shell
 import (
 	"testing"
 
+	ps "github.com/planetscale/cli/internal/planetscale"
+
 	qt "github.com/frankban/quicktest"
 )
 
+func TestShellUsername(t *testing.T) {
+	c := qt.New(t)
+
+	username, err := shellUsername("role-abc", false, "", ps.DatabaseEngineNeki)
+	c.Assert(err, qt.IsNil)
+	c.Assert(username, qt.Equals, "role-abc")
+
+	username, err = shellUsername("role-abc", true, "", ps.DatabaseEnginePostgres)
+	c.Assert(err, qt.IsNil)
+	c.Assert(username, qt.Equals, "role-abc|replica")
+
+	// Neki replica reads go through PGOPTIONS, not the username suffix.
+	username, err = shellUsername("role-abc", true, "", ps.DatabaseEngineNeki)
+	c.Assert(err, qt.IsNil)
+	c.Assert(username, qt.Equals, "role-abc")
+
+	username, err = shellUsername("role-abc", false, "analytics", ps.DatabaseEngineNeki)
+	c.Assert(err, qt.IsNil)
+	c.Assert(username, qt.Equals, "role-abc|analytics")
+
+	username, err = shellUsername("role-abc", true, "analytics", ps.DatabaseEngineNeki)
+	c.Assert(err, qt.IsNil)
+	c.Assert(username, qt.Equals, "role-abc|analytics")
+
+	_, err = shellUsername("role-abc", false, "analytics", ps.DatabaseEnginePostgres)
+	c.Assert(err, qt.ErrorMatches, "--router is only supported for Neki databases")
+}
+
+func TestShellPgOptions(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(shellPgOptions(true, ps.DatabaseEngineNeki), qt.Equals, nekiReplicaOptions)
+	c.Assert(shellPgOptions(false, ps.DatabaseEngineNeki), qt.Equals, "")
+	c.Assert(shellPgOptions(true, ps.DatabaseEnginePostgres), qt.Equals, "")
+}
+
 func TestPostgresPsqlArgs_DefaultDBName(t *testing.T) {
 	c := qt.New(t)
 
diff --git a/internal/cmd/sidecar/changes.go b/internal/cmd/sidecar/changes.go
new file mode 100644
index 000000000..42210247a
--- /dev/null
+++ b/internal/cmd/sidecar/changes.go
@@ -0,0 +1,158 @@
+package sidecar
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ChangesCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "changes <command>",
+		Short: "Manage changes to a Neki sidecar",
+	}
+	cmd.AddCommand(changesListCmd(ch), changesShowCmd(ch), changesCancelCmd(ch))
+	return cmd
+}
+
+func changesListCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		period      string
+		completedAt string
+		page        int
+		perPage     int
+	}
+
+	cmd := &cobra.Command{
+		Use:     "list <database> <branch> <sidecar>",
+		Short:   "List changes for a Neki sidecar",
+		Args:    cmdutil.ExactArgs("database", "branch", "sidecar"),
+		Aliases: []string{"ls"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, sidecar := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching changes for sidecar %s", printer.BoldBlue(sidecar)))
+			defer end()
+			changes, err := client.NekiSidecars.ListChanges(cmd.Context(), &ps.ListNekiSidecarChangesRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Sidecar:      sidecar,
+				Period:       flags.period,
+				CompletedAt:  flags.completedAt,
+				Page:         flags.page,
+				PerPage:      flags.perPage,
+			})
+			if err != nil {
+				return handleError(err, database, branch, sidecar)
+			}
+			end()
+
+			if len(changes) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No changes found for sidecar %s.\n", printer.BoldBlue(sidecar))
+				return nil
+			}
+			return ch.Printer.PrintResource(toChanges(changes))
+		},
+	}
+
+	cmd.Flags().StringVar(&flags.period, "period", "", "Only show changes from this period")
+	cmd.Flags().StringVar(&flags.completedAt, "completed-at", "", "Only show changes completed at this time")
+	cmd.Flags().IntVar(&flags.page, "page", 0, "Page number to fetch")
+	cmd.Flags().IntVar(&flags.perPage, "per-page", 100, "Number of results per page")
+	return cmd
+}
+
+func changesShowCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:     "show <database> <branch> <sidecar> <change-id>",
+		Short:   "Show a change to a Neki sidecar",
+		Args:    cmdutil.ExactArgs("database", "branch", "sidecar", "change-id"),
+		Aliases: []string{"get"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, sidecar, changeID := args[0], args[1], args[2], args[3]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching change %s", printer.BoldBlue(changeID)))
+			defer end()
+			change, err := client.NekiSidecars.GetChange(cmd.Context(), &ps.GetNekiSidecarChangeRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Sidecar:      sidecar,
+				Change:       changeID,
+			})
+			if err != nil {
+				return handleError(err, database, branch, sidecar)
+			}
+			end()
+			if ch.Printer.Format() == printer.Human {
+				if err := ch.Printer.PrintResource(toChange(change)); err != nil {
+					return err
+				}
+
+				differences := changeDifferences(change)
+				if len(differences) == 0 {
+					ch.Printer.Println("No configuration differences.")
+					return nil
+				}
+
+				ch.Printer.Println("Changes:")
+				for _, difference := range differences {
+					ch.Printer.Printf("  Parameter %s: %s → %s\n", difference.Field, difference.Before, difference.After)
+				}
+				return nil
+			}
+			return ch.Printer.PrintResource(toChange(change))
+		},
+	}
+}
+
+func changesCancelCmd(ch *cmdutil.Helper) *cobra.Command {
+	return &cobra.Command{
+		Use:   "cancel <database> <branch> <sidecar> <change-id>",
+		Short: "Cancel a pending change to a Neki sidecar",
+		Args:  cmdutil.ExactArgs("database", "branch", "sidecar", "change-id"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, sidecar, changeID := args[0], args[1], args[2], args[3]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Cancelling change %s", printer.BoldBlue(changeID)))
+			defer end()
+			err = client.NekiSidecars.CancelChange(cmd.Context(), &ps.CancelNekiSidecarChangeRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Sidecar:      sidecar,
+				Change:       changeID,
+			})
+			if err != nil {
+				return handleError(err, database, branch, sidecar)
+			}
+			end()
+
+			if ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("Canceled change %s for sidecar %s.\n", printer.BoldBlue(changeID), printer.BoldBlue(sidecar))
+				return nil
+			}
+			return ch.Printer.PrintResource(map[string]string{
+				"result":    "change canceled",
+				"change_id": changeID,
+				"sidecar":   sidecar,
+			})
+		},
+	}
+}
diff --git a/internal/cmd/sidecar/errors.go b/internal/cmd/sidecar/errors.go
new file mode 100644
index 000000000..ce1906821
--- /dev/null
+++ b/internal/cmd/sidecar/errors.go
@@ -0,0 +1,23 @@
+package sidecar
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+func handleError(err error, database, branch, sidecar string) error {
+	if cmdutil.ErrCode(err) != ps.ErrNotFound {
+		return cmdutil.HandleError(err)
+	}
+
+	if sidecar != "" {
+		return fmt.Errorf("sidecar %s does not exist in branch %s of database %s",
+			printer.BoldBlue(sidecar), printer.BoldBlue(branch), printer.BoldBlue(database))
+	}
+
+	return fmt.Errorf("database %s or branch %s does not exist, or the branch is not a Neki branch",
+		printer.BoldBlue(database), printer.BoldBlue(branch))
+}
diff --git a/internal/cmd/sidecar/list.go b/internal/cmd/sidecar/list.go
new file mode 100644
index 000000000..1425f58b4
--- /dev/null
+++ b/internal/cmd/sidecar/list.go
@@ -0,0 +1,48 @@
+package sidecar
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ListCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "list <database> <branch>",
+		Short:   "List sidecars for a Neki database branch",
+		Args:    cmdutil.ExactArgs("database", "branch"),
+		Aliases: []string{"ls"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch := args[0], args[1]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching sidecars for %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
+			defer end()
+
+			sidecars, err := client.NekiSidecars.List(cmd.Context(), &ps.ListNekiSidecarsRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+			})
+			if err != nil {
+				return handleError(err, database, branch, "")
+			}
+			end()
+
+			if len(sidecars) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No sidecars found in %s/%s.\n", printer.BoldBlue(database), printer.BoldBlue(branch))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(toSidecars(sidecars))
+		},
+	}
+
+	return cmd
+}
diff --git a/internal/cmd/sidecar/parameters.go b/internal/cmd/sidecar/parameters.go
new file mode 100644
index 000000000..d207546eb
--- /dev/null
+++ b/internal/cmd/sidecar/parameters.go
@@ -0,0 +1,50 @@
+package sidecar
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ParametersCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "parameters <database> <branch> <sidecar>",
+		Short:   "List parameters for a Neki sidecar",
+		Long:    "List parameters for a Neki sidecar.\n\n<sidecar> is the sidecar ID from `sidecar list`, or the configuration profile name.",
+		Args:    cmdutil.ExactArgs("database", "branch", "sidecar"),
+		Aliases: []string{"params"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, sidecar := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching parameters for sidecar %s", printer.BoldBlue(sidecar)))
+			defer end()
+
+			parameters, err := client.NekiSidecars.ListParameters(cmd.Context(), &ps.ListNekiSidecarParametersRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Sidecar:      sidecar,
+			})
+			if err != nil {
+				return handleError(err, database, branch, sidecar)
+			}
+			end()
+
+			if len(parameters) == 0 && ch.Printer.Format() == printer.Human {
+				ch.Printer.Printf("No parameters found for sidecar %s.\n", printer.BoldBlue(sidecar))
+				return nil
+			}
+
+			return ch.Printer.PrintResource(toParameters(parameters))
+		},
+	}
+
+	return cmd
+}
diff --git a/internal/cmd/sidecar/show.go b/internal/cmd/sidecar/show.go
new file mode 100644
index 000000000..3cb85d03b
--- /dev/null
+++ b/internal/cmd/sidecar/show.go
@@ -0,0 +1,66 @@
+package sidecar
+
+import (
+	"fmt"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func ShowCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "show <database> <branch> <sidecar>",
+		Short:   "Show a sidecar for a Neki database branch",
+		Long:    "Show a sidecar for a Neki database branch.\n\n<sidecar> is the sidecar ID from `sidecar list`, or the configuration profile name.",
+		Args:    cmdutil.ExactArgs("database", "branch", "sidecar"),
+		Aliases: []string{"get"},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, sidecar := args[0], args[1], args[2]
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching sidecar %s", printer.BoldBlue(sidecar)))
+			defer end()
+
+			resource, err := client.NekiSidecars.Get(cmd.Context(), &ps.GetNekiSidecarRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Sidecar:      sidecar,
+			})
+			if err != nil {
+				return handleError(err, database, branch, sidecar)
+			}
+
+			parameters, err := client.NekiSidecars.ListParameters(cmd.Context(), &ps.ListNekiSidecarParametersRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Sidecar:      sidecar,
+			})
+			if err != nil {
+				return handleError(err, database, branch, sidecar)
+			}
+			end()
+
+			if ch.Printer.Format() != printer.Human {
+				return ch.Printer.PrintResource(toSidecarDetail(resource, parameters))
+			}
+
+			if err := ch.Printer.PrintResource(toSidecar(resource)); err != nil {
+				return err
+			}
+			if len(parameters) == 0 {
+				return nil
+			}
+			ch.Printer.Println()
+			return ch.Printer.PrintResource(toParameters(parameters))
+		},
+	}
+
+	return cmd
+}
diff --git a/internal/cmd/sidecar/sidecar.go b/internal/cmd/sidecar/sidecar.go
new file mode 100644
index 000000000..b6f10307e
--- /dev/null
+++ b/internal/cmd/sidecar/sidecar.go
@@ -0,0 +1,217 @@
+package sidecar
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/spf13/cobra"
+)
+
+func SidecarCmd(ch *cmdutil.Helper) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "sidecar <command>",
+		Short: "Manage sidecars for a Neki database branch",
+		Long:  "Manage sidecars for a Neki database branch.\n\nEach configuration profile has one sidecar. Sidecars are created and deleted with their profile. This command is only supported for Neki databases.",
+	}
+
+	cmd.AddCommand(
+		ChangesCmd(ch),
+		ListCmd(ch),
+		ParametersCmd(ch),
+		ShowCmd(ch),
+		UpdateCmd(ch),
+	)
+
+	return cmd
+}
+
+type sidecarDisplay struct {
+	ID                   string `header:"id" json:"id"`
+	ConfigurationProfile string `header:"configuration profile" json:"configuration_profile"`
+	State                string `header:"state" json:"state"`
+	CreatedAt            string `header:"created at" json:"created_at"`
+
+	orig *ps.NekiSidecar
+}
+
+func (s *sidecarDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.orig)
+}
+
+func (s *sidecarDisplay) MarshalCSVValue() interface{} {
+	return []*sidecarDisplay{s}
+}
+
+func toSidecar(sidecar *ps.NekiSidecar) *sidecarDisplay {
+	return &sidecarDisplay{
+		ID:                   sidecar.ID,
+		ConfigurationProfile: sidecar.ConfigurationProfile,
+		State:                sidecar.State,
+		CreatedAt:            sidecar.CreatedAt.UTC().Format("2006-01-02 15:04:05"),
+		orig:                 sidecar,
+	}
+}
+
+func toSidecars(sidecars []*ps.NekiSidecar) []*sidecarDisplay {
+	out := make([]*sidecarDisplay, 0, len(sidecars))
+	for _, sidecar := range sidecars {
+		out = append(out, toSidecar(sidecar))
+	}
+	return out
+}
+
+type sidecarDetailDisplay struct {
+	*sidecarDisplay
+
+	parameters []*ps.NekiParameter
+}
+
+func (s *sidecarDetailDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		*ps.NekiSidecar
+		Parameters []*ps.NekiParameter `json:"parameters"`
+	}{NekiSidecar: s.orig, Parameters: s.parameters})
+}
+
+func toSidecarDetail(sidecar *ps.NekiSidecar, parameters []*ps.NekiParameter) *sidecarDetailDisplay {
+	return &sidecarDetailDisplay{sidecarDisplay: toSidecar(sidecar), parameters: parameters}
+}
+
+type parameterDisplay struct {
+	Namespace string `header:"namespace" json:"namespace"`
+	Name      string `header:"name" json:"name"`
+	Value     string `header:"value" json:"value"`
+	Default   string `header:"default" json:"default_value"`
+	Type      string `header:"type" json:"parameter_type"`
+	Restart   bool   `header:"restart" json:"restart"`
+
+	orig *ps.NekiParameter
+}
+
+func (p *parameterDisplay) MarshalJSON() ([]byte, error) {
+	return json.Marshal(p.orig)
+}
+
+func (p *parameterDisplay) MarshalCSVValue() interface{} {
+	return []*parameterDisplay{p}
+}
+
+func toParameters(parameters []*ps.NekiParameter) []*parameterDisplay {
+	out := make([]*parameterDisplay, 0, len(parameters))
+	for _, parameter := range parameters {
+		out = append(out, &parameterDisplay{
+			Namespace: parameter.Namespace,
+			Name:      parameter.Name,
+			Value:     formatValue(parameter.Value),
+			Default:   formatValue(parameter.DefaultValue),
+			Type:      parameter.ParameterType,
+			Restart:   parameter.Restart,
+			orig:      parameter,
+		})
+	}
+	return out
+}
+
+func formatValue(v interface{}) string {
+	switch value := v.(type) {
+	case nil:
+		return ""
+	case string:
+		return value
+	case float64:
+		return strconv.FormatFloat(value, 'f', -1, 64)
+	default:
+		return fmt.Sprintf("%v", value)
+	}
+}
+
+type changeDisplay struct {
+	ID        string `header:"id" json:"id"`
+	State     string `header:"state" json:"state"`
+	Changes   string `header:"changes" json:"changes"`
+	CreatedAt string `header:"created at" json:"created_at"`
+	orig      *ps.NekiSidecarChange
+}
+
+func (c *changeDisplay) MarshalJSON() ([]byte, error) { return json.Marshal(c.orig) }
+func (c *changeDisplay) MarshalCSVValue() interface{} { return []*changeDisplay{c} }
+
+func toChange(c *ps.NekiSidecarChange) *changeDisplay {
+	return &changeDisplay{
+		ID:        c.ID,
+		State:     c.State,
+		Changes:   formatChangeSummary(c),
+		CreatedAt: c.CreatedAt.UTC().Format("2006-01-02 15:04:05"),
+		orig:      c,
+	}
+}
+
+func formatChangeSummary(change *ps.NekiSidecarChange) string {
+	differences := changeDifferences(change)
+	if len(differences) == 0 {
+		return ""
+	}
+	parts := make([]string, 0, len(differences))
+	for _, difference := range differences {
+		parts = append(parts, fmt.Sprintf("%s: %s → %s", difference.Field, difference.Before, difference.After))
+	}
+	return strings.Join(parts, ", ")
+}
+
+func toChanges(changes []*ps.NekiSidecarChange) []*changeDisplay {
+	out := make([]*changeDisplay, 0, len(changes))
+	for _, change := range changes {
+		out = append(out, toChange(change))
+	}
+	return out
+}
+
+type changeDifference struct {
+	Field  string
+	Before string
+	After  string
+}
+
+func changeDifferences(change *ps.NekiSidecarChange) []changeDifference {
+	parameterKeys := make(map[string]struct{})
+	for namespace, parameters := range change.PreviousParameters {
+		for name := range parameters {
+			parameterKeys[namespace+"."+name] = struct{}{}
+		}
+	}
+	for namespace, parameters := range change.Parameters {
+		for name := range parameters {
+			parameterKeys[namespace+"."+name] = struct{}{}
+		}
+	}
+
+	keys := make([]string, 0, len(parameterKeys))
+	for key := range parameterKeys {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	differences := make([]changeDifference, 0)
+	for _, key := range keys {
+		namespace, name, _ := strings.Cut(key, ".")
+		before, hadBefore := change.PreviousParameters[namespace][name]
+		after, hasAfter := change.Parameters[namespace][name]
+		if hadBefore && hasAfter && before == after {
+			continue
+		}
+		if !hadBefore {
+			before = "(default)"
+		}
+		if !hasAfter {
+			after = "(default)"
+		}
+		differences = append(differences, changeDifference{Field: key, Before: before, After: after})
+	}
+
+	return differences
+}
diff --git a/internal/cmd/sidecar/sidecar_test.go b/internal/cmd/sidecar/sidecar_test.go
new file mode 100644
index 000000000..6d611f49d
--- /dev/null
+++ b/internal/cmd/sidecar/sidecar_test.go
@@ -0,0 +1,323 @@
+package sidecar
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/planetscale/cli/internal/cmdutil"
+	"github.com/planetscale/cli/internal/config"
+	"github.com/planetscale/cli/internal/mock"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+)
+
+func sidecarTestHelper(svc ps.NekiSidecarsService, out *bytes.Buffer) *cmdutil.Helper {
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(out)
+	return &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiSidecars: svc}, nil
+		},
+	}
+}
+
+func testSidecar() *ps.NekiSidecar {
+	return &ps.NekiSidecar{
+		Type:                 "neki_sidecar",
+		ID:                   "sidecar-1",
+		ConfigurationProfile: "metal",
+		State:                "ready",
+		CreatedAt:            time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+		UpdatedAt:            time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+	}
+}
+
+func TestSidecarListCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiSidecarsService{
+		ListFn: func(_ context.Context, req *ps.ListNekiSidecarsRequest) ([]*ps.NekiSidecar, error) {
+			c.Assert(req, qt.DeepEquals, &ps.ListNekiSidecarsRequest{Organization: "acme", Database: "app", Branch: "main"})
+			return []*ps.NekiSidecar{testSidecar()}, nil
+		},
+	}
+
+	cmd := ListCmd(sidecarTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.ListFnInvoked, qt.IsTrue)
+	c.Assert(out.String(), qt.JSONEquals, []map[string]interface{}{{
+		"type":                  "neki_sidecar",
+		"id":                    "sidecar-1",
+		"configuration_profile": "metal",
+		"state":                 "ready",
+		"created_at":            "2026-08-04T12:00:00Z",
+		"updated_at":            "2026-08-04T12:00:00Z",
+	}})
+}
+
+func TestSidecarListHumanHeadersAndUTC(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	sidecar := testSidecar()
+	sidecar.CreatedAt = time.Date(2026, 8, 4, 12, 0, 0, 0, time.FixedZone("MDT", -6*60*60))
+	svc := &mock.NekiSidecarsService{ListFn: func(context.Context, *ps.ListNekiSidecarsRequest) ([]*ps.NekiSidecar, error) {
+		return []*ps.NekiSidecar{sidecar}, nil
+	}}
+	ch := &cmdutil.Helper{Printer: p, Config: &config.Config{Organization: "acme"}, Client: func() (*ps.Client, error) {
+		return &ps.Client{NekiSidecars: svc}, nil
+	}}
+
+	cmd := ListCmd(ch)
+	cmd.SetArgs([]string{"app", "main"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "ID")
+	c.Assert(out.String(), qt.Contains, "CONFIGURATION PROFILE")
+	c.Assert(out.String(), qt.Contains, "STATE")
+	c.Assert(out.String(), qt.Contains, "CREATED AT")
+	c.Assert(out.String(), qt.Contains, "sidecar-1")
+	c.Assert(out.String(), qt.Contains, "metal")
+	c.Assert(out.String(), qt.Contains, "2026-08-04 18:00:00")
+}
+
+func TestSidecarShowCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiSidecarsService{
+		GetFn: func(_ context.Context, req *ps.GetNekiSidecarRequest) (*ps.NekiSidecar, error) {
+			c.Assert(req, qt.DeepEquals, &ps.GetNekiSidecarRequest{
+				Organization: "acme",
+				Database:     "app",
+				Branch:       "main",
+				Sidecar:      "metal",
+			})
+			return testSidecar(), nil
+		},
+		ListParametersFn: func(_ context.Context, req *ps.ListNekiSidecarParametersRequest) ([]*ps.NekiParameter, error) {
+			c.Assert(req.Sidecar, qt.Equals, "metal")
+			return []*ps.NekiParameter{{
+				Name:          "default_pool_size",
+				Namespace:     "pgbouncer",
+				ParameterType: "integer",
+				DefaultValue:  "10",
+				Value:         "20",
+			}}, nil
+		},
+	}
+
+	cmd := ShowCmd(sidecarTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.GetFnInvoked, qt.IsTrue)
+	c.Assert(svc.ListParametersFnInvoked, qt.IsTrue)
+	var detail map[string]interface{}
+	c.Assert(json.Unmarshal(out.Bytes(), &detail), qt.IsNil)
+	c.Assert(detail["id"], qt.Equals, "sidecar-1")
+	c.Assert(detail["configuration_profile"], qt.Equals, "metal")
+	parameters := detail["parameters"].([]interface{})
+	c.Assert(parameters, qt.HasLen, 1)
+	c.Assert(parameters[0].(map[string]interface{})["name"], qt.Equals, "default_pool_size")
+}
+
+func TestSidecarUpdateCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiSidecarsService{UpdateFn: func(_ context.Context, req *ps.UpdateNekiSidecarRequest) (*ps.NekiSidecar, error) {
+		c.Assert(req.Organization, qt.Equals, "acme")
+		c.Assert(req.Database, qt.Equals, "app")
+		c.Assert(req.Branch, qt.Equals, "main")
+		c.Assert(req.Sidecar, qt.Equals, "metal")
+		c.Assert(req.Parameters, qt.DeepEquals, map[string]map[string]string{
+			"pgbouncer": {"default_pool_size": "20", "max_client_conn": "100"},
+		})
+		return testSidecar(), nil
+	}}
+
+	cmd := UpdateCmd(sidecarTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "--parameters", "pgbouncer.default_pool_size=20", "--parameters", "pgbouncer.max_client_conn=100"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(svc.UpdateFnInvoked, qt.IsTrue)
+}
+
+func TestSidecarUpdateCmdRequiresParameters(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiSidecarsService{}
+
+	cmd := UpdateCmd(sidecarTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal"})
+	err := cmd.Execute()
+	c.Assert(err, qt.ErrorMatches, "at least one --parameters flag is required")
+	c.Assert(svc.UpdateFnInvoked, qt.IsFalse)
+}
+
+func TestSidecarUpdateCmdInvalidParameters(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiSidecarsService{}
+
+	cmd := UpdateCmd(sidecarTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "--parameters", "bogus"})
+	err := cmd.Execute()
+	c.Assert(err, qt.ErrorMatches, `invalid --parameters "bogus": expected namespace.name=value`)
+}
+
+func TestSidecarParametersCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiSidecarsService{ListParametersFn: func(_ context.Context, req *ps.ListNekiSidecarParametersRequest) ([]*ps.NekiParameter, error) {
+		c.Assert(req, qt.DeepEquals, &ps.ListNekiSidecarParametersRequest{Organization: "acme", Database: "app", Branch: "main", Sidecar: "metal"})
+		return []*ps.NekiParameter{
+			{Name: "default_pool_size", Namespace: "pgbouncer", Value: "20"},
+		}, nil
+	}}
+
+	cmd := ParametersCmd(sidecarTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, []map[string]interface{}{{
+		"name": "default_pool_size", "display_name": "", "namespace": "pgbouncer", "advanced": false,
+		"category": nil, "description": "", "parameter_type": "", "default_value": nil, "value": "20",
+		"required": false, "created_at": "0001-01-01T00:00:00Z", "updated_at": nil, "restart": false, "url": "",
+	}})
+}
+
+func TestSidecarChangesCancelCmd(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	svc := &mock.NekiSidecarsService{CancelChangeFn: func(_ context.Context, req *ps.CancelNekiSidecarChangeRequest) error {
+		c.Assert(req, qt.DeepEquals, &ps.CancelNekiSidecarChangeRequest{Organization: "acme", Database: "app", Branch: "main", Sidecar: "metal", Change: "change-1"})
+		return nil
+	}}
+
+	cmd := changesCancelCmd(sidecarTestHelper(svc, &out))
+	cmd.SetArgs([]string{"app", "main", "metal", "change-1"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.JSONEquals, map[string]interface{}{
+		"result": "change canceled", "change_id": "change-1", "sidecar": "metal",
+	})
+}
+
+func TestSidecarChangesListHumanDisplaysDifferences(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	svc := &mock.NekiSidecarsService{ListChangesFn: func(_ context.Context, req *ps.ListNekiSidecarChangesRequest) ([]*ps.NekiSidecarChange, error) {
+		c.Assert(req, qt.DeepEquals, &ps.ListNekiSidecarChangesRequest{
+			Organization: "acme",
+			Database:     "app",
+			Branch:       "main",
+			Sidecar:      "metal",
+			PerPage:      100,
+		})
+		return []*ps.NekiSidecarChange{{
+			ID:        "change-1",
+			State:     "completed",
+			CreatedAt: time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+			Parameters: map[string]map[string]string{"pgbouncer": {
+				"default_pool_size": "20",
+				"max_client_conn":   "100",
+			}},
+			PreviousParameters: map[string]map[string]string{"pgbouncer": {
+				"default_pool_size":  "10",
+				"query_wait_timeout": "120",
+			}},
+		}}, nil
+	}}
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiSidecars: svc}, nil
+		},
+	}
+
+	cmd := changesListCmd(ch)
+	cmd.SetArgs([]string{"app", "main", "metal"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "CHANGES")
+	c.Assert(out.String(), qt.Contains, "pgbouncer.default_pool_size: 10 → 20")
+	c.Assert(out.String(), qt.Contains, "pgbouncer.max_client_conn: (default) → 100")
+	c.Assert(out.String(), qt.Contains, "pgbouncer.query_wait_timeout: 120 → (default)")
+}
+
+func TestSidecarChangesShowHumanDisplaysDifferences(t *testing.T) {
+	c := qt.New(t)
+	var out bytes.Buffer
+	format := printer.Human
+	p := printer.NewPrinter(&format)
+	p.SetHumanOutput(&out)
+	p.SetResourceOutput(&out)
+	svc := &mock.NekiSidecarsService{GetChangeFn: func(_ context.Context, req *ps.GetNekiSidecarChangeRequest) (*ps.NekiSidecarChange, error) {
+		c.Assert(req, qt.DeepEquals, &ps.GetNekiSidecarChangeRequest{
+			Organization: "acme",
+			Database:     "app",
+			Branch:       "main",
+			Sidecar:      "metal",
+			Change:       "change-1",
+		})
+		return &ps.NekiSidecarChange{
+			ID:        "change-1",
+			State:     "applying",
+			CreatedAt: time.Date(2026, 8, 4, 12, 0, 0, 0, time.UTC),
+			Parameters: map[string]map[string]string{"pgbouncer": {
+				"default_pool_size": "20",
+				"max_client_conn":   "100",
+			}},
+			PreviousParameters: map[string]map[string]string{"pgbouncer": {
+				"default_pool_size":  "10",
+				"query_wait_timeout": "120",
+			}},
+		}, nil
+	}}
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config:  &config.Config{Organization: "acme"},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{NekiSidecars: svc}, nil
+		},
+	}
+
+	cmd := changesShowCmd(ch)
+	cmd.SetArgs([]string{"app", "main", "metal", "change-1"})
+	c.Assert(cmd.Execute(), qt.IsNil)
+	c.Assert(out.String(), qt.Contains, "Changes:")
+	c.Assert(out.String(), qt.Contains, "Parameter pgbouncer.default_pool_size: 10 → 20")
+	c.Assert(out.String(), qt.Contains, "Parameter pgbouncer.max_client_conn: (default) → 100")
+	c.Assert(out.String(), qt.Contains, "Parameter pgbouncer.query_wait_timeout: 120 → (default)")
+}
+
+func TestSidecarCmdSubcommands(t *testing.T) {
+	cmd := SidecarCmd(&cmdutil.Helper{Config: &config.Config{}})
+	for _, name := range []string{"changes", "list", "parameters", "show", "update"} {
+		found, _, err := cmd.Find([]string{name})
+		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, found.Name(), qt.Equals, name)
+	}
+
+	changes, _, err := cmd.Find([]string{"changes"})
+	qt.Assert(t, err, qt.IsNil)
+	for _, name := range []string{"cancel", "list", "show"} {
+		found, _, err := changes.Find([]string{name})
+		qt.Assert(t, err, qt.IsNil)
+		qt.Assert(t, found.Name(), qt.Equals, name)
+	}
+
+	for _, sub := range cmd.Commands() {
+		qt.Assert(t, sub.Name() == "create" || sub.Name() == "delete", qt.IsFalse)
+	}
+}
diff --git a/internal/cmd/sidecar/update.go b/internal/cmd/sidecar/update.go
new file mode 100644
index 000000000..31f50cf50
--- /dev/null
+++ b/internal/cmd/sidecar/update.go
@@ -0,0 +1,84 @@
+package sidecar
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/planetscale/cli/internal/cmdutil"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
+	"github.com/spf13/cobra"
+)
+
+func UpdateCmd(ch *cmdutil.Helper) *cobra.Command {
+	var flags struct {
+		parameters []string
+	}
+
+	cmd := &cobra.Command{
+		Use:   "update <database> <branch> <sidecar>",
+		Short: "Update a sidecar for a Neki database branch",
+		Long:  "Update a sidecar for a Neki database branch.\n\n<sidecar> is the sidecar ID from `sidecar list`, or the configuration profile name.\nChanges are requested and applied asynchronously; the sidecar state shows progress.",
+		Args:  cmdutil.ExactArgs("database", "branch", "sidecar"),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			database, branch, sidecar := args[0], args[1], args[2]
+
+			if !cmd.Flags().Changed("parameters") {
+				return fmt.Errorf("at least one --parameters flag is required")
+			}
+
+			parameters, err := parseParameters(flags.parameters)
+			if err != nil {
+				return err
+			}
+
+			client, err := ch.Client()
+			if err != nil {
+				return err
+			}
+
+			end := ch.Printer.PrintProgress(fmt.Sprintf("Updating sidecar %s", printer.BoldBlue(sidecar)))
+			defer end()
+
+			resource, err := client.NekiSidecars.Update(cmd.Context(), &ps.UpdateNekiSidecarRequest{
+				Organization: ch.Config.Organization,
+				Database:     database,
+				Branch:       branch,
+				Sidecar:      sidecar,
+				Parameters:   parameters,
+			})
+			if err != nil {
+				return handleError(err, database, branch, sidecar)
+			}
+			end()
+
+			return ch.Printer.PrintResource(toSidecar(resource))
+		},
+	}
+
+	cmd.Flags().StringArrayVar(&flags.parameters, "parameters", nil, "Set a parameter as namespace.name=value; repeatable")
+
+	return cmd
+}
+
+func parseParameters(values []string) (map[string]map[string]string, error) {
+	if len(values) == 0 {
+		return nil, nil
+	}
+	out := make(map[string]map[string]string)
+	for _, value := range values {
+		key, setting, ok := strings.Cut(value, "=")
+		if !ok {
+			return nil, fmt.Errorf("invalid --parameters %q: expected namespace.name=value", value)
+		}
+		namespace, name, ok := strings.Cut(key, ".")
+		if !ok || namespace == "" || name == "" {
+			return nil, fmt.Errorf("invalid --parameters %q: expected namespace.name=value", value)
+		}
+		if out[namespace] == nil {
+			out[namespace] = make(map[string]string)
+		}
+		out[namespace][name] = setting
+	}
+	return out, nil
+}
diff --git a/internal/cmd/size/cluster.go b/internal/cmd/size/cluster.go
index fe9b42807..2e4997158 100644
--- a/internal/cmd/size/cluster.go
+++ b/internal/cmd/size/cluster.go
@@ -58,40 +58,35 @@ func ListCmd(ch *cmdutil.Helper) *cobra.Command {
 			var allClusterSKUsWithEngine []clusterSKUWithEngine
 
 			if showAll {
-				// Make two API calls: one for MySQL, one for PostgreSQL
-				// MySQL clusters (without WithPostgreSQL)
-				mysqlSKUs, err := client.Organizations.ListClusterSKUs(ctx, &planetscale.ListOrganizationClusterSKUsRequest{
-					Organization: ch.Config.Organization,
-				}, baseOpts...)
-				if err != nil {
-					return cmdutil.HandleError(err)
-				}
-				for _, sku := range mysqlSKUs {
-					allClusterSKUsWithEngine = append(allClusterSKUsWithEngine, clusterSKUWithEngine{
-						sku:    sku,
-						engine: planetscale.DatabaseEngineMySQL,
-					})
+				engines := []struct {
+					engine planetscale.DatabaseEngine
+					opts   []planetscale.ListOption
+				}{
+					{planetscale.DatabaseEngineMySQL, baseOpts},
+					{planetscale.DatabaseEnginePostgres, append(baseOpts, planetscale.WithPostgreSQL())},
+					{planetscale.DatabaseEngineNeki, append(baseOpts, planetscale.WithNeki())},
 				}
-
-				// PostgreSQL clusters (with WithPostgreSQL)
-				postgresOpts := append(baseOpts, planetscale.WithPostgreSQL())
-				postgresSKUs, err := client.Organizations.ListClusterSKUs(ctx, &planetscale.ListOrganizationClusterSKUsRequest{
-					Organization: ch.Config.Organization,
-				}, postgresOpts...)
-				if err != nil {
-					return cmdutil.HandleError(err)
-				}
-				for _, sku := range postgresSKUs {
-					allClusterSKUsWithEngine = append(allClusterSKUsWithEngine, clusterSKUWithEngine{
-						sku:    sku,
-						engine: planetscale.DatabaseEnginePostgres,
-					})
+				for _, item := range engines {
+					skus, err := client.Organizations.ListClusterSKUs(ctx, &planetscale.ListOrganizationClusterSKUsRequest{
+						Organization: ch.Config.Organization,
+					}, item.opts...)
+					if err != nil {
+						return cmdutil.HandleError(err)
+					}
+					for _, sku := range skus {
+						allClusterSKUsWithEngine = append(allClusterSKUsWithEngine, clusterSKUWithEngine{
+							sku:    sku,
+							engine: item.engine,
+						})
+					}
 				}
 			} else {
-				// Single engine filter
 				listOpts := baseOpts
-				if engine == planetscale.DatabaseEnginePostgres {
+				switch engine {
+				case planetscale.DatabaseEnginePostgres:
 					listOpts = append(listOpts, planetscale.WithPostgreSQL())
+				case planetscale.DatabaseEngineNeki:
+					listOpts = append(listOpts, planetscale.WithNeki())
 				}
 
 				clusterSKUs, err := client.Organizations.ListClusterSKUs(ctx, &planetscale.ListOrganizationClusterSKUsRequest{
@@ -119,7 +114,7 @@ func ListCmd(ch *cmdutil.Helper) *cobra.Command {
 
 	cmd.Flags().StringVar(&flags.region, "region", "", "view cluster sizes and rates for a specific region")
 	cmd.Flags().BoolVar(&flags.metal, "metal", false, "view cluster sizes and rates for clusters with metal storage")
-	cmd.Flags().StringVar(&flags.engine, "engine", "", "Filter cluster sizes by database engine. Supported values: mysql, postgresql. If not specified, shows all clusters for all engines.")
+	cmd.Flags().StringVar(&flags.engine, "engine", "", "Filter cluster sizes by database engine. Supported values: mysql, postgresql, neki. If not specified, shows all clusters for all engines.")
 
 	cmd.RegisterFlagCompletionFunc("region", func(cmd *cobra.Command, args []string, toComplete string) ([]cobra.Completion, cobra.ShellCompDirective) {
 		return cmdutil.RegionsCompletionFunc(ch, cmd, args, toComplete)
@@ -129,6 +124,7 @@ func ListCmd(ch *cmdutil.Helper) *cobra.Command {
 		return []cobra.Completion{
 			cobra.CompletionWithDesc("mysql", "A Vitess database"),
 			cobra.CompletionWithDesc("postgresql", "The fastest cloud Postgres"),
+			cobra.CompletionWithDesc("neki", "Sharded PostgreSQL"),
 		}, cobra.ShellCompDirectiveNoFileComp
 	})
 
@@ -156,7 +152,7 @@ type ClusterSKU struct {
 	rate *int64
 }
 
-// ClusterSKUSingleEngine is the format for single-engine views (--engine mysql or --engine postgresql).
+// ClusterSKUSingleEngine is the format for single-engine views (--engine mysql, postgresql, or neki).
 // Same as ClusterSKU but without the engine column (since it's implied by the filter).
 type ClusterSKUSingleEngine struct {
 	Name          string `header:"name" json:"name"`
@@ -204,6 +200,21 @@ func (c *ClusterSKUSingleEngine) MarshalCSVValue() interface{} {
 	return []*ClusterSKUSingleEngine{c}
 }
 
+func postgresLike(engine planetscale.DatabaseEngine) bool {
+	return engine == planetscale.DatabaseEnginePostgres || engine == planetscale.DatabaseEngineNeki
+}
+
+func engineDisplayName(engine planetscale.DatabaseEngine) string {
+	switch engine {
+	case planetscale.DatabaseEnginePostgres:
+		return "postgresql"
+	case planetscale.DatabaseEngineNeki:
+		return "neki"
+	default:
+		return "mysql"
+	}
+}
+
 func parseDatabaseEngine(engine string) (planetscale.DatabaseEngine, bool, error) {
 	switch engine {
 	case "":
@@ -212,8 +223,10 @@ func parseDatabaseEngine(engine string) (planetscale.DatabaseEngine, bool, error
 		return planetscale.DatabaseEngineMySQL, false, nil
 	case "postgresql", "postgres":
 		return planetscale.DatabaseEnginePostgres, false, nil
+	case "neki":
+		return planetscale.DatabaseEngineNeki, false, nil
 	default:
-		return planetscale.DatabaseEngineMySQL, false, fmt.Errorf("invalid database engine %q, supported values: mysql, postgresql", engine)
+		return planetscale.DatabaseEngineMySQL, false, fmt.Errorf("invalid database engine %q, supported values: mysql, postgresql, neki", engine)
 	}
 }
 
@@ -252,7 +265,7 @@ func formatClusterFields(sku *planetscale.ClusterSKU, rateOverride *int64) (name
 }
 
 // toClusterSKUs converts cluster SKUs to the full format with all columns including engine.
-// PostgreSQL clusters appear twice (highly available and single node).
+// PostgreSQL and Neki clusters appear twice (highly available and single node).
 // MySQL clusters are always highly available with 2 replicas.
 func toClusterSKUs(items []clusterSKUWithEngine, onlyMetal bool) []*ClusterSKU {
 	clusters := make([]*ClusterSKU, 0, len(items)*2)
@@ -262,12 +275,9 @@ func toClusterSKUs(items []clusterSKUWithEngine, onlyMetal bool) []*ClusterSKU {
 			continue
 		}
 
-		engineStr := "mysql"
-		if item.engine == planetscale.DatabaseEnginePostgres {
-			engineStr = "postgresql"
-		}
+		engineStr := engineDisplayName(item.engine)
 
-		if item.engine == planetscale.DatabaseEnginePostgres {
+		if postgresLike(item.engine) {
 			// Highly available version with regular rate
 			name, cpu, memory, storage, price := formatClusterFields(item.sku, nil)
 			clusters = append(clusters, &ClusterSKU{
@@ -322,7 +332,7 @@ func toClusterSKUs(items []clusterSKUWithEngine, onlyMetal bool) []*ClusterSKU {
 }
 
 // toClusterSKUsSingleEngine converts cluster SKUs to the single-engine format (no engine column).
-// PostgreSQL clusters appear twice (highly available and single node).
+// PostgreSQL and Neki clusters appear twice (highly available and single node).
 // MySQL clusters are always highly available with 2 replicas.
 func toClusterSKUsSingleEngine(items []clusterSKUWithEngine, onlyMetal bool) []*ClusterSKUSingleEngine {
 	clusters := make([]*ClusterSKUSingleEngine, 0, len(items)*2)
@@ -332,7 +342,7 @@ func toClusterSKUsSingleEngine(items []clusterSKUWithEngine, onlyMetal bool) []*
 			continue
 		}
 
-		if item.engine == planetscale.DatabaseEnginePostgres {
+		if postgresLike(item.engine) {
 			// Highly available version with regular rate
 			name, cpu, memory, storage, price := formatClusterFields(item.sku, nil)
 			clusters = append(clusters, &ClusterSKUSingleEngine{
diff --git a/internal/cmd/size/cluster_test.go b/internal/cmd/size/cluster_test.go
index 1790823e7..521fcbb4c 100644
--- a/internal/cmd/size/cluster_test.go
+++ b/internal/cmd/size/cluster_test.go
@@ -37,11 +37,14 @@ func TestSizeCluster_ListCmd_DefaultShowsAll(t *testing.T) {
 		ListClusterSKUsFn: func(ctx context.Context, req *ps.ListOrganizationClusterSKUsRequest, opts ...ps.ListOption) ([]*ps.ClusterSKU, error) {
 			c.Assert(req.Organization, qt.Equals, org)
 			callCount++
-			// First call is MySQL (no WithPostgreSQL), second is PostgreSQL (with WithPostgreSQL)
-			if callCount == 1 {
+			switch callCount {
+			case 1:
 				return mysqlSKUs, nil
+			case 2:
+				return postgresSKUs, nil
+			default:
+				return postgresSKUs, nil
 			}
-			return postgresSKUs, nil
 		},
 	}
 
@@ -62,7 +65,7 @@ func TestSizeCluster_ListCmd_DefaultShowsAll(t *testing.T) {
 
 	c.Assert(err, qt.IsNil)
 	c.Assert(svc.ListClusterSKUsFnInvoked, qt.IsTrue)
-	c.Assert(callCount, qt.Equals, 2) // Should make 2 calls (MySQL and PostgreSQL)
+	c.Assert(callCount, qt.Equals, 3) // MySQL, PostgreSQL, and Neki
 
 	// Verify output contains clusters from both engines
 	c.Assert(buf.String(), qt.Contains, "PS-10")
@@ -117,6 +120,53 @@ func TestSizeCluster_ListCmd_PostgreSQL(t *testing.T) {
 	c.Assert(buf.String(), qt.JSONEquals, res)
 }
 
+func TestSizeCluster_ListCmd_Neki(t *testing.T) {
+	c := qt.New(t)
+
+	var buf bytes.Buffer
+	format := printer.JSON
+	p := printer.NewPrinter(&format)
+	p.SetResourceOutput(&buf)
+
+	org := "planetscale"
+
+	orig := []*ps.ClusterSKU{
+		{Name: "PS-10", Enabled: true, Rate: testutil.Pointer[int64](39), ReplicaRate: testutil.Pointer[int64](13)},
+	}
+	svc := &mock.OrganizationsService{
+		ListClusterSKUsFn: func(ctx context.Context, req *ps.ListOrganizationClusterSKUsRequest, opts ...ps.ListOption) ([]*ps.ClusterSKU, error) {
+			c.Assert(req.Organization, qt.Equals, org)
+			return orig, nil
+		},
+	}
+
+	ch := &cmdutil.Helper{
+		Printer: p,
+		Config: &config.Config{
+			Organization: org,
+		},
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{
+				Organizations: svc,
+			}, nil
+		},
+	}
+
+	cmd := ListCmd(ch)
+	cmd.SetArgs([]string{"--engine", "neki"})
+	err := cmd.Execute()
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(svc.ListClusterSKUsFnInvoked, qt.IsTrue)
+
+	res := []*ClusterSKUSingleEngine{
+		{Configuration: "highly available", Replicas: "2", orig: orig[0], rate: orig[0].Rate},
+		{Configuration: "single node", Replicas: "0", orig: orig[0], rate: orig[0].ReplicaRate},
+	}
+
+	c.Assert(buf.String(), qt.JSONEquals, res)
+}
+
 func TestSizeCluster_ListCmd_MySQL(t *testing.T) {
 	c := qt.New(t)
 
@@ -232,6 +282,7 @@ func TestParseDatabaseEngine(t *testing.T) {
 		{input: "mysql", wantEngine: ps.DatabaseEngineMySQL, wantShowAll: false, wantErr: false},
 		{input: "postgresql", wantEngine: ps.DatabaseEnginePostgres, wantShowAll: false, wantErr: false},
 		{input: "postgres", wantEngine: ps.DatabaseEnginePostgres, wantShowAll: false, wantErr: false},
+		{input: "neki", wantEngine: ps.DatabaseEngineNeki, wantShowAll: false, wantErr: false},
 		{input: "invalid", wantEngine: ps.DatabaseEngineMySQL, wantShowAll: false, wantErr: true},
 	}
 
diff --git a/internal/cmd/sql/sql.go b/internal/cmd/sql/sql.go
index 7a5abf093..c2416b327 100644
--- a/internal/cmd/sql/sql.go
+++ b/internal/cmd/sql/sql.go
@@ -39,7 +39,7 @@ Pass --keyspace when targeting a specific keyspace in a multi-keyspace database.
 include a shard and tablet type (mykeyspace/-80, mykeyspace/-80@replica) to pin the connection to
 one shard; enumerate shards with SHOW VITESS_SHARDS.
 
-PostgreSQL databases use --dbname (default postgres).
+Postgres or Neki databases use --dbname (default postgres).
 
 Human output prints rows as a table. Pass --vertical (or end the query with \G,
 like the mysql client) to print one column per line, which is easier to read for
@@ -96,7 +96,7 @@ Place flags after positional arguments (see Usage). --org is required:
 		"The organization for the current user")
 	cmd.Flags().StringVar(&flags.query, "query", "", "SQL query to execute")
 	cmd.Flags().StringVar(&flags.keyspace, "keyspace", "", "Vitess keyspace, optionally with a shard and tablet type (e.g. mykeyspace, mykeyspace/-80, mykeyspace/-80@replica). List shards with --query \"SHOW VITESS_SHARDS\". Defaults to @primary, same as pscale shell.")
-	cmd.Flags().StringVar(&flags.postgresDB, "dbname", "postgres", "PostgreSQL database name")
+	cmd.Flags().StringVar(&flags.postgresDB, "dbname", "postgres", "Postgres or Neki database name")
 	cmd.Flags().StringVar(&flags.role, "role",
 		"", "Role defines the access level, allowed values are: reader, writer, readwriter, admin. Defaults to reader (use --role admin for writes).")
 	cmd.Flags().BoolVar(&flags.replica, "replica", false,
diff --git a/internal/cmdutil/args_test.go b/internal/cmdutil/args_test.go
new file mode 100644
index 000000000..aceb0fafb
--- /dev/null
+++ b/internal/cmdutil/args_test.go
@@ -0,0 +1,25 @@
+package cmdutil
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+func TestExactArgs(t *testing.T) {
+	cmd := &cobra.Command{Use: "test <database> <branch>"}
+	validate := ExactArgs("database", "branch")
+
+	if err := validate(cmd, []string{"app", "main"}); err != nil {
+		t.Fatalf("exact arguments returned error: %v", err)
+	}
+
+	if err := validate(cmd, []string{"app"}); err == nil || !strings.Contains(err.Error(), "missing argument <branch>") {
+		t.Fatalf("missing argument error = %v", err)
+	}
+
+	if err := validate(cmd, []string{"app", "main", "extra"}); err == nil || !strings.Contains(err.Error(), "accepts 2 arg(s), received 3") {
+		t.Fatalf("extra argument error = %v", err)
+	}
+}
diff --git a/internal/cmdutil/cmdutil.go b/internal/cmdutil/cmdutil.go
index 02fbdee3d..7f2e0abae 100644
--- a/internal/cmdutil/cmdutil.go
+++ b/internal/cmdutil/cmdutil.go
@@ -142,6 +142,18 @@ func RequiredArgs(reqArgs ...string) cobra.PositionalArgs {
 	}
 }
 
+func ExactArgs(reqArgs ...string) cobra.PositionalArgs {
+	required := RequiredArgs(reqArgs...)
+
+	return func(cmd *cobra.Command, args []string) error {
+		if err := required(cmd, args); err != nil {
+			return err
+		}
+
+		return cobra.ExactArgs(len(reqArgs))(cmd, args)
+	}
+}
+
 // CheckAuthentication checks whether the user is authenticated and returns a
 // actionable error message.
 func CheckAuthentication(cfg *config.Config) func(cmd *cobra.Command, args []string) error {
@@ -396,6 +408,177 @@ func ToClusterSizeSlug(c string) string {
 	return strings.ReplaceAll(c, "_", "-")
 }
 
+// ToSizeSKUName converts a user-facing size slug (PS-10, NKR-5) to the API
+// SKU name (PS_10, NKR_5).
+func ToSizeSKUName(c string) string {
+	return strings.ReplaceAll(c, "-", "_")
+}
+
+const (
+	ConfigProfileSizeFlagHelp = "For Neki backup restores, size and replica count for one configuration profile as name=<profile>[,cluster-size=<size>][,replicas=<n>]. Repeatable. Omitted profiles inherit the source. List names with 'pscale branch config-profile list' on the source branch."
+	RouterSizeFlagHelp        = "For Neki backup restores, size and replica count for one router as name=<router>[,size=<sku>][,replicas-per-cell=<n>]. Repeatable. Omitted routers inherit the source. List names with 'pscale branch router list' on the source branch."
+)
+
+// EnsureNekiRestoreSizing rejects --config-profile/--router unless this is a Neki backup restore.
+func EnsureNekiRestoreSizing(kind ps.DatabaseEngine, restoring, seedData, hasFlags bool) error {
+	if !hasFlags {
+		return nil
+	}
+	if kind != ps.DatabaseEngineNeki {
+		return fmt.Errorf("--config-profile and --router are only supported for Neki backup restores")
+	}
+	if !restoring {
+		return fmt.Errorf("--config-profile and --router can only be used when restoring a backup")
+	}
+	if seedData {
+		return fmt.Errorf("--config-profile and --router are not supported with --seed-data")
+	}
+	return nil
+}
+
+// ParseConfigurationProfileSizes parses repeatable --config-profile flags.
+func ParseConfigurationProfileSizes(raw []string) ([]ps.ConfigurationProfileSize, error) {
+	if len(raw) == 0 {
+		return nil, nil
+	}
+	out := make([]ps.ConfigurationProfileSize, 0, len(raw))
+	seen := make(map[string]struct{}, len(raw))
+	for _, s := range raw {
+		entry, err := parseConfigurationProfileSize(s)
+		if err != nil {
+			return nil, err
+		}
+		if _, ok := seen[entry.Name]; ok {
+			return nil, fmt.Errorf("duplicate --config-profile name %q", entry.Name)
+		}
+		seen[entry.Name] = struct{}{}
+		out = append(out, entry)
+	}
+	return out, nil
+}
+
+func parseConfigurationProfileSize(s string) (ps.ConfigurationProfileSize, error) {
+	var entry ps.ConfigurationProfileSize
+	hasOverride := false
+	for part := range strings.SplitSeq(s, ",") {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		k, v, ok := strings.Cut(part, "=")
+		if !ok {
+			return entry, fmt.Errorf("invalid --config-profile %q: expected name=<profile>[,cluster-size=<size>][,replicas=<n>]", s)
+		}
+		k = strings.TrimSpace(k)
+		v = strings.TrimSpace(v)
+		switch k {
+		case "name":
+			entry.Name = v
+		case "cluster-size":
+			if v == "" {
+				return entry, fmt.Errorf("invalid --config-profile %q: cluster-size must not be empty", s)
+			}
+			entry.ClusterSize = ToSizeSKUName(v)
+			hasOverride = true
+		case "replicas":
+			n, err := strconv.Atoi(v)
+			if err != nil {
+				return entry, fmt.Errorf("invalid --config-profile %q: replicas must be an integer", s)
+			}
+			entry.Replicas = &n
+			hasOverride = true
+		default:
+			return entry, fmt.Errorf("unknown --config-profile field %q in %q: valid fields are name, cluster-size, replicas", k, s)
+		}
+	}
+	if entry.Name == "" {
+		return entry, fmt.Errorf("--config-profile %q is missing required field name", s)
+	}
+	if !hasOverride {
+		return entry, fmt.Errorf("--config-profile %q must set cluster-size and/or replicas", s)
+	}
+	return entry, nil
+}
+
+// ParseRouterSizes parses repeatable --router flags.
+func ParseRouterSizes(raw []string) ([]ps.RouterSize, error) {
+	if len(raw) == 0 {
+		return nil, nil
+	}
+	out := make([]ps.RouterSize, 0, len(raw))
+	seen := make(map[string]struct{}, len(raw))
+	for _, s := range raw {
+		entry, err := parseRouterSize(s)
+		if err != nil {
+			return nil, err
+		}
+		if _, ok := seen[entry.Name]; ok {
+			return nil, fmt.Errorf("duplicate --router name %q", entry.Name)
+		}
+		seen[entry.Name] = struct{}{}
+		out = append(out, entry)
+	}
+	return out, nil
+}
+
+func parseRouterSize(s string) (ps.RouterSize, error) {
+	var entry ps.RouterSize
+	hasOverride := false
+	for part := range strings.SplitSeq(s, ",") {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		k, v, ok := strings.Cut(part, "=")
+		if !ok {
+			return entry, fmt.Errorf("invalid --router %q: expected name=<router>[,size=<sku>][,replicas-per-cell=<n>]", s)
+		}
+		k = strings.TrimSpace(k)
+		v = strings.TrimSpace(v)
+		switch k {
+		case "name":
+			entry.Name = v
+		case "size":
+			if v == "" {
+				return entry, fmt.Errorf("invalid --router %q: size must not be empty", s)
+			}
+			entry.RouterSize = ToSizeSKUName(v)
+			hasOverride = true
+		case "replicas-per-cell":
+			n, err := strconv.Atoi(v)
+			if err != nil {
+				return entry, fmt.Errorf("invalid --router %q: replicas-per-cell must be an integer", s)
+			}
+			entry.ReplicasPerCell = &n
+			hasOverride = true
+		default:
+			return entry, fmt.Errorf("unknown --router field %q in %q: valid fields are name, size, replicas-per-cell", k, s)
+		}
+	}
+	if entry.Name == "" {
+		return entry, fmt.Errorf("--router %q is missing required field name", s)
+	}
+	if !hasOverride {
+		return entry, fmt.Errorf("--router %q must set size and/or replicas-per-cell", s)
+	}
+	return entry, nil
+}
+
+// ApplyNekiRestoreSizing copies parsed --config-profile/--router flags onto a branch create request.
+func ApplyNekiRestoreSizing(req *ps.CreatePostgresBranchRequest, configProfiles, routers []string) error {
+	profiles, err := ParseConfigurationProfileSizes(configProfiles)
+	if err != nil {
+		return err
+	}
+	routerSizes, err := ParseRouterSizes(routers)
+	if err != nil {
+		return err
+	}
+	req.ConfigurationProfileSizes = profiles
+	req.RouterSizes = routerSizes
+	return nil
+}
+
 func SnakeToSentenceCase(s string) string {
 	titleCaser := cases.Title(language.English)
 
diff --git a/internal/cmdutil/json_error.go b/internal/cmdutil/json_error.go
index 8bddb6f02..a8f3e7b20 100644
--- a/internal/cmdutil/json_error.go
+++ b/internal/cmdutil/json_error.go
@@ -100,11 +100,12 @@ func GlobalJSONError(err error) JSONErrorResponse {
 	case strings.Contains(msg, "missing argument") ||
 		strings.Contains(msg, "missing arguments") ||
 		strings.Contains(msg, "missing required flags") ||
-		strings.Contains(msg, "required flag"):
+		strings.Contains(msg, "required flag") ||
+		(strings.Contains(msg, "accepts ") && strings.Contains(msg, " arg(s), received ")):
 		status = "action_required"
 		code = "INVALID_USAGE"
 		nextSteps = []string{
-			"Re-run with the missing arguments or flags named in the error message",
+			"Re-run with the arguments and flags described by the error message",
 			AgentGuideCmd(),
 		}
 
diff --git a/internal/cmdutil/json_error_test.go b/internal/cmdutil/json_error_test.go
index f5f17c8ac..501bf6476 100644
--- a/internal/cmdutil/json_error_test.go
+++ b/internal/cmdutil/json_error_test.go
@@ -37,6 +37,16 @@ func TestGlobalJSONErrorInvalidUsageSkipsAuth(t *testing.T) {
 	}
 }
 
+func TestGlobalJSONErrorExtraArgumentsAreInvalidUsage(t *testing.T) {
+	resp := GlobalJSONError(errors.New("accepts 3 arg(s), received 4"))
+	if resp.Status != "action_required" {
+		t.Fatalf("status = %q", resp.Status)
+	}
+	if resp.Code() != "INVALID_USAGE" {
+		t.Fatalf("code = %q", resp.Code())
+	}
+}
+
 func TestGlobalJSONErrorOrgFlagPlacement(t *testing.T) {
 	resp := GlobalJSONError(errors.New("unknown flag: --org"))
 	if resp.Code() != "INVALID_FLAG_PLACEMENT" {
diff --git a/internal/cmdutil/neki_restore_test.go b/internal/cmdutil/neki_restore_test.go
new file mode 100644
index 000000000..7a13a4354
--- /dev/null
+++ b/internal/cmdutil/neki_restore_test.go
@@ -0,0 +1,82 @@
+package cmdutil
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+	ps "github.com/planetscale/cli/internal/planetscale"
+)
+
+func TestParseConfigurationProfileSizes(t *testing.T) {
+	c := qt.New(t)
+
+	replicas := 2
+	zero := 0
+
+	got, err := ParseConfigurationProfileSizes([]string{
+		"name=default,cluster-size=PS-40,replicas=2",
+		"name=analytics, replicas = 0",
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(got, qt.DeepEquals, []ps.ConfigurationProfileSize{
+		{Name: "default", ClusterSize: "PS_40", Replicas: &replicas},
+		{Name: "analytics", Replicas: &zero},
+	})
+}
+
+func TestParseConfigurationProfileSizesErrors(t *testing.T) {
+	c := qt.New(t)
+
+	_, err := ParseConfigurationProfileSizes([]string{"cluster-size=PS_40"})
+	c.Assert(err, qt.ErrorMatches, `.*missing required field name`)
+
+	_, err = ParseConfigurationProfileSizes([]string{"name=default"})
+	c.Assert(err, qt.ErrorMatches, `.*must set cluster-size and/or replicas`)
+
+	_, err = ParseConfigurationProfileSizes([]string{"name=default,replicas=two"})
+	c.Assert(err, qt.ErrorMatches, `.*replicas must be an integer`)
+
+	_, err = ParseConfigurationProfileSizes([]string{"name=default,cluster-size=PS_10", "name=default,replicas=1"})
+	c.Assert(err, qt.ErrorMatches, `duplicate --config-profile name "default"`)
+
+	_, err = ParseConfigurationProfileSizes([]string{"name=default,metal=true"})
+	c.Assert(err, qt.ErrorMatches, `unknown --config-profile field "metal".*`)
+}
+
+func TestParseRouterSizes(t *testing.T) {
+	c := qt.New(t)
+
+	replicas := 1
+	got, err := ParseRouterSizes([]string{"name=default,size=NKR-20,replicas-per-cell=1"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(got, qt.DeepEquals, []ps.RouterSize{
+		{Name: "default", RouterSize: "NKR_20", ReplicasPerCell: &replicas},
+	})
+}
+
+func TestParseRouterSizesErrors(t *testing.T) {
+	c := qt.New(t)
+
+	_, err := ParseRouterSizes([]string{"size=NKR_20"})
+	c.Assert(err, qt.ErrorMatches, `.*missing required field name`)
+
+	_, err = ParseRouterSizes([]string{"name=default"})
+	c.Assert(err, qt.ErrorMatches, `.*must set size and/or replicas-per-cell`)
+
+	_, err = ParseRouterSizes([]string{"name=default,replicas-per-cell=x"})
+	c.Assert(err, qt.ErrorMatches, `.*replicas-per-cell must be an integer`)
+
+	_, err = ParseRouterSizes([]string{"name=default,size=NKR_10", "name=default,replicas-per-cell=1"})
+	c.Assert(err, qt.ErrorMatches, `duplicate --router name "default"`)
+}
+
+func TestEnsureNekiRestoreSizing(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(EnsureNekiRestoreSizing(ps.DatabaseEngineMySQL, true, false, false), qt.IsNil)
+	c.Assert(EnsureNekiRestoreSizing(ps.DatabaseEngineNeki, true, false, true), qt.IsNil)
+
+	c.Assert(EnsureNekiRestoreSizing(ps.DatabaseEnginePostgres, true, false, true), qt.ErrorMatches, `.*only supported for Neki backup restores`)
+	c.Assert(EnsureNekiRestoreSizing(ps.DatabaseEngineNeki, false, false, true), qt.ErrorMatches, `.*can only be used when restoring a backup`)
+	c.Assert(EnsureNekiRestoreSizing(ps.DatabaseEngineNeki, true, true, true), qt.ErrorMatches, `.*not supported with --seed-data`)
+}
diff --git a/internal/cmdutil/postgres.go b/internal/cmdutil/postgres.go
index dc035965c..46dba1bab 100644
--- a/internal/cmdutil/postgres.go
+++ b/internal/cmdutil/postgres.go
@@ -31,3 +31,26 @@ func RequirePostgresDatabase(ctx context.Context, client *ps.Client, org, databa
 	}
 	return nil
 }
+
+// RequirePostgresOrNekiDatabase fetches the database and errors if it is
+// missing or neither PostgreSQL nor Neki.
+func RequirePostgresOrNekiDatabase(ctx context.Context, client *ps.Client, org, database, resourcePlural string) error {
+	db, err := client.Databases.Get(ctx, &ps.GetDatabaseRequest{
+		Organization: org,
+		Database:     database,
+	})
+	if err != nil {
+		switch ErrCode(err) {
+		case ps.ErrNotFound:
+			return fmt.Errorf("database %s does not exist in organization %s",
+				printer.BoldBlue(database), printer.BoldBlue(org))
+		default:
+			return HandleError(err)
+		}
+	}
+	if db.Kind != ps.DatabaseEnginePostgres && db.Kind != ps.DatabaseEngineNeki {
+		return fmt.Errorf("%s are only available for Postgres and Neki databases; %s is %s",
+			resourcePlural, printer.BoldBlue(database), printer.BoldBlue(string(db.Kind)))
+	}
+	return nil
+}
diff --git a/internal/mock/branch.go b/internal/mock/branch.go
index 9221f4b7a..cef292541 100644
--- a/internal/mock/branch.go
+++ b/internal/mock/branch.go
@@ -34,6 +34,12 @@ type DatabaseBranchesService struct {
 	UpdateRoutingRulesFn        func(context.Context, *ps.UpdateBranchRoutingRulesRequest) (*ps.RoutingRules, error)
 	UpdateRoutingRulesFnInvoked bool
 
+	DataTopologyFn        func(context.Context, *ps.BranchDataTopologyRequest) (*ps.DataTopology, error)
+	DataTopologyFnInvoked bool
+
+	UpdateDataTopologyFn        func(context.Context, *ps.UpdateBranchDataTopologyRequest) (*ps.DataTopology, error)
+	UpdateDataTopologyFnInvoked bool
+
 	RefreshSchemaFn        func(context.Context, *ps.RefreshSchemaRequest) error
 	RefreshSchemaFnInvoked bool
 
@@ -113,6 +119,16 @@ func (d *DatabaseBranchesService) UpdateRoutingRules(ctx context.Context, req *p
 	return d.UpdateRoutingRulesFn(ctx, req)
 }
 
+func (d *DatabaseBranchesService) DataTopology(ctx context.Context, req *ps.BranchDataTopologyRequest) (*ps.DataTopology, error) {
+	d.DataTopologyFnInvoked = true
+	return d.DataTopologyFn(ctx, req)
+}
+
+func (d *DatabaseBranchesService) UpdateDataTopology(ctx context.Context, req *ps.UpdateBranchDataTopologyRequest) (*ps.DataTopology, error) {
+	d.UpdateDataTopologyFnInvoked = true
+	return d.UpdateDataTopologyFn(ctx, req)
+}
+
 func (d *DatabaseBranchesService) RefreshSchema(ctx context.Context, req *ps.RefreshSchemaRequest) error {
 	d.RefreshSchemaFnInvoked = true
 	return d.RefreshSchemaFn(ctx, req)
diff --git a/internal/mock/neki_admins.go b/internal/mock/neki_admins.go
new file mode 100644
index 000000000..8186eb0ad
--- /dev/null
+++ b/internal/mock/neki_admins.go
@@ -0,0 +1,65 @@
+package mock
+
+import (
+	"context"
+
+	ps "github.com/planetscale/cli/internal/planetscale"
+)
+
+type NekiAdminsService struct {
+	GetFn        func(context.Context, *ps.GetNekiAdminRequest) (*ps.NekiAdmin, error)
+	GetFnInvoked bool
+
+	UpdateFn        func(context.Context, *ps.UpdateNekiAdminRequest) (*ps.NekiAdmin, error)
+	UpdateFnInvoked bool
+
+	ListParametersFn        func(context.Context, *ps.ListNekiAdminParametersRequest) ([]*ps.NekiParameter, error)
+	ListParametersFnInvoked bool
+
+	ListSizeSKUsFn        func(context.Context, *ps.ListNekiAdminSizeSKUsRequest) ([]*ps.NekiAdminSKU, error)
+	ListSizeSKUsFnInvoked bool
+
+	ListChangesFn        func(context.Context, *ps.ListNekiAdminChangesRequest) ([]*ps.NekiAdminChange, error)
+	ListChangesFnInvoked bool
+
+	GetChangeFn        func(context.Context, *ps.GetNekiAdminChangeRequest) (*ps.NekiAdminChange, error)
+	GetChangeFnInvoked bool
+
+	CancelChangeFn        func(context.Context, *ps.CancelNekiAdminChangeRequest) error
+	CancelChangeFnInvoked bool
+}
+
+func (s *NekiAdminsService) Get(ctx context.Context, req *ps.GetNekiAdminRequest) (*ps.NekiAdmin, error) {
+	s.GetFnInvoked = true
+	return s.GetFn(ctx, req)
+}
+
+func (s *NekiAdminsService) Update(ctx context.Context, req *ps.UpdateNekiAdminRequest) (*ps.NekiAdmin, error) {
+	s.UpdateFnInvoked = true
+	return s.UpdateFn(ctx, req)
+}
+
+func (s *NekiAdminsService) ListParameters(ctx context.Context, req *ps.ListNekiAdminParametersRequest) ([]*ps.NekiParameter, error) {
+	s.ListParametersFnInvoked = true
+	return s.ListParametersFn(ctx, req)
+}
+
+func (s *NekiAdminsService) ListSizeSKUs(ctx context.Context, req *ps.ListNekiAdminSizeSKUsRequest) ([]*ps.NekiAdminSKU, error) {
+	s.ListSizeSKUsFnInvoked = true
+	return s.ListSizeSKUsFn(ctx, req)
+}
+
+func (s *NekiAdminsService) ListChanges(ctx context.Context, req *ps.ListNekiAdminChangesRequest) ([]*ps.NekiAdminChange, error) {
+	s.ListChangesFnInvoked = true
+	return s.ListChangesFn(ctx, req)
+}
+
+func (s *NekiAdminsService) GetChange(ctx context.Context, req *ps.GetNekiAdminChangeRequest) (*ps.NekiAdminChange, error) {
+	s.GetChangeFnInvoked = true
+	return s.GetChangeFn(ctx, req)
+}
+
+func (s *NekiAdminsService) CancelChange(ctx context.Context, req *ps.CancelNekiAdminChangeRequest) error {
+	s.CancelChangeFnInvoked = true
+	return s.CancelChangeFn(ctx, req)
+}
diff --git a/internal/mock/neki_routers.go b/internal/mock/neki_routers.go
new file mode 100644
index 000000000..faa9e7187
--- /dev/null
+++ b/internal/mock/neki_routers.go
@@ -0,0 +1,89 @@
+package mock
+
+import (
+	"context"
+
+	ps "github.com/planetscale/cli/internal/planetscale"
+)
+
+type NekiRoutersService struct {
+	ListFn        func(context.Context, *ps.ListNekiRoutersRequest) ([]*ps.NekiRouter, error)
+	ListFnInvoked bool
+
+	GetFn        func(context.Context, *ps.GetNekiRouterRequest) (*ps.NekiRouter, error)
+	GetFnInvoked bool
+
+	CreateFn        func(context.Context, *ps.CreateNekiRouterRequest) (*ps.NekiRouter, error)
+	CreateFnInvoked bool
+
+	UpdateFn        func(context.Context, *ps.UpdateNekiRouterRequest) (*ps.NekiRouter, error)
+	UpdateFnInvoked bool
+
+	DeleteFn        func(context.Context, *ps.DeleteNekiRouterRequest) error
+	DeleteFnInvoked bool
+
+	ListParametersFn        func(context.Context, *ps.ListNekiRouterParametersRequest) ([]*ps.NekiParameter, error)
+	ListParametersFnInvoked bool
+
+	ListSizeSKUsFn        func(context.Context, *ps.ListNekiRouterSizeSKUsRequest) ([]*ps.NekiRouterSKU, error)
+	ListSizeSKUsFnInvoked bool
+
+	ListChangesFn        func(context.Context, *ps.ListNekiRouterChangesRequest) ([]*ps.NekiRouterChange, error)
+	ListChangesFnInvoked bool
+
+	GetChangeFn        func(context.Context, *ps.GetNekiRouterChangeRequest) (*ps.NekiRouterChange, error)
+	GetChangeFnInvoked bool
+
+	CancelChangeFn        func(context.Context, *ps.CancelNekiRouterChangeRequest) error
+	CancelChangeFnInvoked bool
+}
+
+func (s *NekiRoutersService) List(ctx context.Context, req *ps.ListNekiRoutersRequest) ([]*ps.NekiRouter, error) {
+	s.ListFnInvoked = true
+	return s.ListFn(ctx, req)
+}
+
+func (s *NekiRoutersService) Get(ctx context.Context, req *ps.GetNekiRouterRequest) (*ps.NekiRouter, error) {
+	s.GetFnInvoked = true
+	return s.GetFn(ctx, req)
+}
+
+func (s *NekiRoutersService) Create(ctx context.Context, req *ps.CreateNekiRouterRequest) (*ps.NekiRouter, error) {
+	s.CreateFnInvoked = true
+	return s.CreateFn(ctx, req)
+}
+
+func (s *NekiRoutersService) Update(ctx context.Context, req *ps.UpdateNekiRouterRequest) (*ps.NekiRouter, error) {
+	s.UpdateFnInvoked = true
+	return s.UpdateFn(ctx, req)
+}
+
+func (s *NekiRoutersService) Delete(ctx context.Context, req *ps.DeleteNekiRouterRequest) error {
+	s.DeleteFnInvoked = true
+	return s.DeleteFn(ctx, req)
+}
+
+func (s *NekiRoutersService) ListParameters(ctx context.Context, req *ps.ListNekiRouterParametersRequest) ([]*ps.NekiParameter, error) {
+	s.ListParametersFnInvoked = true
+	return s.ListParametersFn(ctx, req)
+}
+
+func (s *NekiRoutersService) ListSizeSKUs(ctx context.Context, req *ps.ListNekiRouterSizeSKUsRequest) ([]*ps.NekiRouterSKU, error) {
+	s.ListSizeSKUsFnInvoked = true
+	return s.ListSizeSKUsFn(ctx, req)
+}
+
+func (s *NekiRoutersService) ListChanges(ctx context.Context, req *ps.ListNekiRouterChangesRequest) ([]*ps.NekiRouterChange, error) {
+	s.ListChangesFnInvoked = true
+	return s.ListChangesFn(ctx, req)
+}
+
+func (s *NekiRoutersService) GetChange(ctx context.Context, req *ps.GetNekiRouterChangeRequest) (*ps.NekiRouterChange, error) {
+	s.GetChangeFnInvoked = true
+	return s.GetChangeFn(ctx, req)
+}
+
+func (s *NekiRoutersService) CancelChange(ctx context.Context, req *ps.CancelNekiRouterChangeRequest) error {
+	s.CancelChangeFnInvoked = true
+	return s.CancelChangeFn(ctx, req)
+}
diff --git a/internal/mock/neki_shard_configuration_profiles.go b/internal/mock/neki_shard_configuration_profiles.go
new file mode 100644
index 000000000..5aa7dfeda
--- /dev/null
+++ b/internal/mock/neki_shard_configuration_profiles.go
@@ -0,0 +1,92 @@
+package mock
+
+import (
+	"context"
+
+	ps "github.com/planetscale/cli/internal/planetscale"
+)
+
+type NekiShardConfigurationProfilesService struct {
+	ListFn               func(context.Context, *ps.ListNekiShardConfigurationProfilesRequest) ([]*ps.NekiShardConfigurationProfile, error)
+	GetFn                func(context.Context, *ps.GetNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error)
+	CreateFn             func(context.Context, *ps.CreateNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error)
+	UpdateFn             func(context.Context, *ps.UpdateNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error)
+	DeleteFn             func(context.Context, *ps.DeleteNekiShardConfigurationProfileRequest) error
+	GetDefaultFn         func(context.Context, *ps.GetDefaultNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error)
+	SetDefaultFn         func(context.Context, *ps.SetDefaultNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error)
+	ListParametersFn     func(context.Context, *ps.ListNekiShardConfigurationProfileParametersRequest) ([]*ps.NekiParameter, error)
+	ListExtensionsFn     func(context.Context, *ps.ListNekiShardConfigurationProfileExtensionsRequest) ([]*ps.NekiExtension, error)
+	UpdateExtensionFn    func(context.Context, *ps.UpdateNekiShardConfigurationProfileExtensionRequest) (*ps.NekiExtension, error)
+	RunMaintenanceFn     func(context.Context, *ps.RunNekiShardConfigurationProfileMaintenanceRequest) error
+	RunBulkMaintenanceFn func(context.Context, *ps.RunNekiShardConfigurationProfilesMaintenanceRequest) error
+	ListChangesFn        func(context.Context, *ps.ListNekiShardConfigurationProfileChangesRequest) ([]*ps.NekiShardConfigurationProfileChange, error)
+	GetChangeFn          func(context.Context, *ps.GetNekiShardConfigurationProfileChangeRequest) (*ps.NekiShardConfigurationProfileChange, error)
+	CancelChangeFn       func(context.Context, *ps.CancelNekiShardConfigurationProfileChangeRequest) error
+
+	ListFnInvoked, GetFnInvoked, CreateFnInvoked, UpdateFnInvoked, DeleteFnInvoked bool
+	GetDefaultFnInvoked, SetDefaultFnInvoked                                       bool
+	ListParametersFnInvoked, ListExtensionsFnInvoked, UpdateExtensionFnInvoked     bool
+	RunMaintenanceFnInvoked, RunBulkMaintenanceFnInvoked                           bool
+	ListChangesFnInvoked, GetChangeFnInvoked, CancelChangeFnInvoked                bool
+}
+
+func (s *NekiShardConfigurationProfilesService) List(ctx context.Context, r *ps.ListNekiShardConfigurationProfilesRequest) ([]*ps.NekiShardConfigurationProfile, error) {
+	s.ListFnInvoked = true
+	return s.ListFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) Get(ctx context.Context, r *ps.GetNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+	s.GetFnInvoked = true
+	return s.GetFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) Create(ctx context.Context, r *ps.CreateNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+	s.CreateFnInvoked = true
+	return s.CreateFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) Update(ctx context.Context, r *ps.UpdateNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+	s.UpdateFnInvoked = true
+	return s.UpdateFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) Delete(ctx context.Context, r *ps.DeleteNekiShardConfigurationProfileRequest) error {
+	s.DeleteFnInvoked = true
+	return s.DeleteFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) GetDefault(ctx context.Context, r *ps.GetDefaultNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+	s.GetDefaultFnInvoked = true
+	return s.GetDefaultFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) SetDefault(ctx context.Context, r *ps.SetDefaultNekiShardConfigurationProfileRequest) (*ps.NekiShardConfigurationProfile, error) {
+	s.SetDefaultFnInvoked = true
+	return s.SetDefaultFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) ListParameters(ctx context.Context, r *ps.ListNekiShardConfigurationProfileParametersRequest) ([]*ps.NekiParameter, error) {
+	s.ListParametersFnInvoked = true
+	return s.ListParametersFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) ListExtensions(ctx context.Context, r *ps.ListNekiShardConfigurationProfileExtensionsRequest) ([]*ps.NekiExtension, error) {
+	s.ListExtensionsFnInvoked = true
+	return s.ListExtensionsFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) UpdateExtension(ctx context.Context, r *ps.UpdateNekiShardConfigurationProfileExtensionRequest) (*ps.NekiExtension, error) {
+	s.UpdateExtensionFnInvoked = true
+	return s.UpdateExtensionFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) RunMaintenance(ctx context.Context, r *ps.RunNekiShardConfigurationProfileMaintenanceRequest) error {
+	s.RunMaintenanceFnInvoked = true
+	return s.RunMaintenanceFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) RunBulkMaintenance(ctx context.Context, r *ps.RunNekiShardConfigurationProfilesMaintenanceRequest) error {
+	s.RunBulkMaintenanceFnInvoked = true
+	return s.RunBulkMaintenanceFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) ListChanges(ctx context.Context, r *ps.ListNekiShardConfigurationProfileChangesRequest) ([]*ps.NekiShardConfigurationProfileChange, error) {
+	s.ListChangesFnInvoked = true
+	return s.ListChangesFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) GetChange(ctx context.Context, r *ps.GetNekiShardConfigurationProfileChangeRequest) (*ps.NekiShardConfigurationProfileChange, error) {
+	s.GetChangeFnInvoked = true
+	return s.GetChangeFn(ctx, r)
+}
+func (s *NekiShardConfigurationProfilesService) CancelChange(ctx context.Context, r *ps.CancelNekiShardConfigurationProfileChangeRequest) error {
+	s.CancelChangeFnInvoked = true
+	return s.CancelChangeFn(ctx, r)
+}
diff --git a/internal/mock/neki_shards.go b/internal/mock/neki_shards.go
new file mode 100644
index 000000000..3ac7683d7
--- /dev/null
+++ b/internal/mock/neki_shards.go
@@ -0,0 +1,57 @@
+package mock
+
+import (
+	"context"
+
+	ps "github.com/planetscale/cli/internal/planetscale"
+)
+
+type NekiShardsService struct {
+	ListFn        func(context.Context, *ps.ListNekiShardsRequest) ([]*ps.NekiShard, error)
+	ListFnInvoked bool
+
+	GetFn        func(context.Context, *ps.GetNekiShardRequest) (*ps.NekiShard, error)
+	GetFnInvoked bool
+
+	CreateFn        func(context.Context, *ps.CreateNekiShardsRequest) (*ps.CreateNekiShardsResponse, error)
+	CreateFnInvoked bool
+
+	AssignFn        func(context.Context, *ps.AssignNekiShardsRequest) ([]*ps.NekiShardAssignment, error)
+	AssignFnInvoked bool
+
+	UpdateFn        func(context.Context, *ps.UpdateNekiShardRequest) (*ps.NekiShard, error)
+	UpdateFnInvoked bool
+
+	DeleteFn        func(context.Context, *ps.DeleteNekiShardRequest) error
+	DeleteFnInvoked bool
+}
+
+func (s *NekiShardsService) List(ctx context.Context, req *ps.ListNekiShardsRequest) ([]*ps.NekiShard, error) {
+	s.ListFnInvoked = true
+	return s.ListFn(ctx, req)
+}
+
+func (s *NekiShardsService) Get(ctx context.Context, req *ps.GetNekiShardRequest) (*ps.NekiShard, error) {
+	s.GetFnInvoked = true
+	return s.GetFn(ctx, req)
+}
+
+func (s *NekiShardsService) Create(ctx context.Context, req *ps.CreateNekiShardsRequest) (*ps.CreateNekiShardsResponse, error) {
+	s.CreateFnInvoked = true
+	return s.CreateFn(ctx, req)
+}
+
+func (s *NekiShardsService) Assign(ctx context.Context, req *ps.AssignNekiShardsRequest) ([]*ps.NekiShardAssignment, error) {
+	s.AssignFnInvoked = true
+	return s.AssignFn(ctx, req)
+}
+
+func (s *NekiShardsService) Update(ctx context.Context, req *ps.UpdateNekiShardRequest) (*ps.NekiShard, error) {
+	s.UpdateFnInvoked = true
+	return s.UpdateFn(ctx, req)
+}
+
+func (s *NekiShardsService) Delete(ctx context.Context, req *ps.DeleteNekiShardRequest) error {
+	s.DeleteFnInvoked = true
+	return s.DeleteFn(ctx, req)
+}
diff --git a/internal/mock/neki_sidecars.go b/internal/mock/neki_sidecars.go
new file mode 100644
index 000000000..f709094fa
--- /dev/null
+++ b/internal/mock/neki_sidecars.go
@@ -0,0 +1,65 @@
+package mock
+
+import (
+	"context"
+
+	ps "github.com/planetscale/cli/internal/planetscale"
+)
+
+type NekiSidecarsService struct {
+	ListFn        func(context.Context, *ps.ListNekiSidecarsRequest) ([]*ps.NekiSidecar, error)
+	ListFnInvoked bool
+
+	GetFn        func(context.Context, *ps.GetNekiSidecarRequest) (*ps.NekiSidecar, error)
+	GetFnInvoked bool
+
+	UpdateFn        func(context.Context, *ps.UpdateNekiSidecarRequest) (*ps.NekiSidecar, error)
+	UpdateFnInvoked bool
+
+	ListParametersFn        func(context.Context, *ps.ListNekiSidecarParametersRequest) ([]*ps.NekiParameter, error)
+	ListParametersFnInvoked bool
+
+	ListChangesFn        func(context.Context, *ps.ListNekiSidecarChangesRequest) ([]*ps.NekiSidecarChange, error)
+	ListChangesFnInvoked bool
+
+	GetChangeFn        func(context.Context, *ps.GetNekiSidecarChangeRequest) (*ps.NekiSidecarChange, error)
+	GetChangeFnInvoked bool
+
+	CancelChangeFn        func(context.Context, *ps.CancelNekiSidecarChangeRequest) error
+	CancelChangeFnInvoked bool
+}
+
+func (s *NekiSidecarsService) List(ctx context.Context, req *ps.ListNekiSidecarsRequest) ([]*ps.NekiSidecar, error) {
+	s.ListFnInvoked = true
+	return s.ListFn(ctx, req)
+}
+
+func (s *NekiSidecarsService) Get(ctx context.Context, req *ps.GetNekiSidecarRequest) (*ps.NekiSidecar, error) {
+	s.GetFnInvoked = true
+	return s.GetFn(ctx, req)
+}
+
+func (s *NekiSidecarsService) Update(ctx context.Context, req *ps.UpdateNekiSidecarRequest) (*ps.NekiSidecar, error) {
+	s.UpdateFnInvoked = true
+	return s.UpdateFn(ctx, req)
+}
+
+func (s *NekiSidecarsService) ListParameters(ctx context.Context, req *ps.ListNekiSidecarParametersRequest) ([]*ps.NekiParameter, error) {
+	s.ListParametersFnInvoked = true
+	return s.ListParametersFn(ctx, req)
+}
+
+func (s *NekiSidecarsService) ListChanges(ctx context.Context, req *ps.ListNekiSidecarChangesRequest) ([]*ps.NekiSidecarChange, error) {
+	s.ListChangesFnInvoked = true
+	return s.ListChangesFn(ctx, req)
+}
+
+func (s *NekiSidecarsService) GetChange(ctx context.Context, req *ps.GetNekiSidecarChangeRequest) (*ps.NekiSidecarChange, error) {
+	s.GetChangeFnInvoked = true
+	return s.GetChangeFn(ctx, req)
+}
+
+func (s *NekiSidecarsService) CancelChange(ctx context.Context, req *ps.CancelNekiSidecarChangeRequest) error {
+	s.CancelChangeFnInvoked = true
+	return s.CancelChangeFn(ctx, req)
+}
diff --git a/internal/planetscale/branches.go b/internal/planetscale/branches.go
index 910f81a91..151bef8be 100644
--- a/internal/planetscale/branches.go
+++ b/internal/planetscale/branches.go
@@ -186,6 +186,8 @@ type DatabaseBranchesService interface {
 	Schema(context.Context, *BranchSchemaRequest) ([]*Diff, error)
 	RoutingRules(context.Context, *BranchRoutingRulesRequest) (*RoutingRules, error)
 	UpdateRoutingRules(context.Context, *UpdateBranchRoutingRulesRequest) (*RoutingRules, error)
+	DataTopology(context.Context, *BranchDataTopologyRequest) (*DataTopology, error)
+	UpdateDataTopology(context.Context, *UpdateBranchDataTopologyRequest) (*DataTopology, error)
 	RefreshSchema(context.Context, *RefreshSchemaRequest) error
 	Demote(context.Context, *DemoteRequest) (*DatabaseBranch, error)
 	Promote(context.Context, *PromoteRequest) (*DatabaseBranch, error)
diff --git a/internal/planetscale/client.go b/internal/planetscale/client.go
index 79a5682d8..a5ed64541 100644
--- a/internal/planetscale/client.go
+++ b/internal/planetscale/client.go
@@ -49,49 +49,55 @@ type Client struct {
 	// base URL for the API
 	baseURL *url.URL
 
-	AuditLogs                AuditLogsService
-	AuthAttemptExports       AuthAttemptExportsService
-	BackupPolicies           BackupPoliciesService
-	Backups                  BackupsService
-	BranchInfrastructure     BranchInfrastructureService
-	BranchMaintenance        BranchMaintenanceService
-	D1ImportNotifications    D1ImportNotificationsService
-	DatabaseBranches         DatabaseBranchesService
-	Databases                DatabasesService
-	DataImports              DataImportsService
-	DeployRequests           DeployRequestsService
-	Invoices                 InvoicesService
-	Keyspaces                KeyspacesService
-	LookupVindex             LookupVindexService
-	MaintenanceSchedules     MaintenanceSchedulesService
-	Materialize              MaterializeService
-	Metrics                  MetricsService
-	MoveTables               MoveTablesService
-	Organizations            OrganizationsService
-	OrganizationSSO          OrganizationSSOService
-	Passwords                PasswordsService
-	PaymentMethods           BillingPaymentMethodsService
-	PaymentMethodSetups      BillingPaymentMethodSetupsService
-	PlannedReparentShard     PlannedReparentShardService
-	PostgresBranches         PostgresBranchesService
-	PostgresBouncers         PostgresBouncersService
-	PostgresCIDRs            PostgresCIDRsService
-	PostgresReadOnlyReplicas PostgresReadOnlyReplicasService
-	PostgresRoles            PostgresRolesService
-	PostgresSwitchovers      PostgresSwitchoversService
-	Processlist              ProcesslistService
-	QueryInsights            QueryInsightsService
-	QueryPatterns            QueryPatternsService
-	ReadOnlyRegions          ReadOnlyRegionsService
-	Regions                  RegionsService
-	SchemaRecommendations    SchemaRecommendationService
-	ServiceTokens            ServiceTokenService
-	TrafficBudgets           TrafficBudgetsService
-	TrafficRules             TrafficRulesService
-	VDiff                    VDiffService
-	Vtctld                   VtctldService
-	Webhooks                 WebhooksService
-	Workflows                WorkflowsService
+	AuditLogs                      AuditLogsService
+	AuthAttemptExports             AuthAttemptExportsService
+	BackupPolicies                 BackupPoliciesService
+	Backups                        BackupsService
+	BranchInfrastructure           BranchInfrastructureService
+	BranchMaintenance              BranchMaintenanceService
+	D1ImportNotifications          D1ImportNotificationsService
+	DatabaseBranches               DatabaseBranchesService
+	Databases                      DatabasesService
+	DataImports                    DataImportsService
+	DeployRequests                 DeployRequestsService
+	Invoices                       InvoicesService
+	Keyspaces                      KeyspacesService
+	Logs                           LogsService
+	LookupVindex                   LookupVindexService
+	MaintenanceSchedules           MaintenanceSchedulesService
+	Materialize                    MaterializeService
+	Metrics                        MetricsService
+	MoveTables                     MoveTablesService
+	NekiAdmins                     NekiAdminsService
+	NekiRouters                    NekiRoutersService
+	NekiSidecars                   NekiSidecarsService
+	NekiShardConfigurationProfiles NekiShardConfigurationProfilesService
+	NekiShards                     NekiShardsService
+	Organizations                  OrganizationsService
+	OrganizationSSO                OrganizationSSOService
+	Passwords                      PasswordsService
+	PaymentMethods                 BillingPaymentMethodsService
+	PaymentMethodSetups            BillingPaymentMethodSetupsService
+	PlannedReparentShard           PlannedReparentShardService
+	PostgresBranches               PostgresBranchesService
+	PostgresBouncers               PostgresBouncersService
+	PostgresCIDRs                  PostgresCIDRsService
+	PostgresReadOnlyReplicas       PostgresReadOnlyReplicasService
+	PostgresRoles                  PostgresRolesService
+	PostgresSwitchovers            PostgresSwitchoversService
+	Processlist                    ProcesslistService
+	QueryInsights                  QueryInsightsService
+	QueryPatterns                  QueryPatternsService
+	ReadOnlyRegions                ReadOnlyRegionsService
+	Regions                        RegionsService
+	SchemaRecommendations          SchemaRecommendationService
+	ServiceTokens                  ServiceTokenService
+	TrafficBudgets                 TrafficBudgetsService
+	TrafficRules                   TrafficRulesService
+	VDiff                          VDiffService
+	Vtctld                         VtctldService
+	Webhooks                       WebhooksService
+	Workflows                      WorkflowsService
 }
 
 // ListOptions are options for listing responses.
@@ -154,6 +160,14 @@ func WithPostgreSQL() ListOption {
 	}
 }
 
+// WithNeki returns a ListOption that sets the "engine" URL parameter to neki.
+func WithNeki() ListOption {
+	return func(opt *ListOptions) error {
+		opt.URLValues.Set("engine", "neki")
+		return nil
+	}
+}
+
 // WithRegion returns a ListOption sets the "region" URL parameter.
 func WithRegion(region string) ListOption {
 	return func(opt *ListOptions) error {
@@ -344,11 +358,17 @@ func NewClient(opts ...ClientOption) (*Client, error) {
 	c.DeployRequests = &deployRequestsService{client: c}
 	c.Invoices = &invoicesService{client: c}
 	c.Keyspaces = &keyspacesService{client: c}
+	c.Logs = &logsService{client: c}
 	c.LookupVindex = &lookupVindexService{client: c}
 	c.MaintenanceSchedules = &maintenanceSchedulesService{client: c}
 	c.Materialize = &materializeService{client: c}
 	c.Metrics = &metricsService{client: c}
 	c.MoveTables = &moveTablesService{client: c}
+	c.NekiAdmins = &nekiAdminsService{client: c}
+	c.NekiRouters = &nekiRoutersService{client: c}
+	c.NekiSidecars = &nekiSidecarsService{client: c}
+	c.NekiShardConfigurationProfiles = &nekiShardConfigurationProfilesService{client: c}
+	c.NekiShards = &nekiShardsService{client: c}
 	c.Organizations = &organizationsService{client: c}
 	c.OrganizationSSO = &organizationSSOService{client: c}
 	c.Passwords = &passwordsService{client: c}
diff --git a/internal/planetscale/data_topology.go b/internal/planetscale/data_topology.go
new file mode 100644
index 000000000..14052b473
--- /dev/null
+++ b/internal/planetscale/data_topology.go
@@ -0,0 +1,62 @@
+package planetscale
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"path"
+	"time"
+)
+
+type DataTopology struct {
+	ID           string          `json:"id"`
+	Type         string          `json:"type"`
+	DataTopology json.RawMessage `json:"data_topology"`
+	SyncedAt     *time.Time      `json:"synced_at"`
+}
+
+type BranchDataTopologyRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+}
+
+type UpdateBranchDataTopologyRequest struct {
+	Organization string          `json:"-"`
+	Database     string          `json:"-"`
+	Branch       string          `json:"-"`
+	DataTopology json.RawMessage `json:"data_topology"`
+}
+
+func (d *databaseBranchesService) DataTopology(ctx context.Context, dataTopologyReq *BranchDataTopologyRequest) (*DataTopology, error) {
+	p := path.Join(databaseBranchAPIPath(dataTopologyReq.Organization, dataTopologyReq.Database, dataTopologyReq.Branch), "data-topology")
+
+	req, err := d.client.newRequest(http.MethodGet, p, nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating http request: %w", err)
+	}
+
+	dataTopology := &DataTopology{}
+	if err := d.client.do(ctx, req, dataTopology); err != nil {
+		return nil, err
+	}
+
+	return dataTopology, nil
+}
+
+func (d *databaseBranchesService) UpdateDataTopology(ctx context.Context, updateReq *UpdateBranchDataTopologyRequest) (*DataTopology, error) {
+	p := path.Join(databaseBranchAPIPath(updateReq.Organization, updateReq.Database, updateReq.Branch), "data-topology")
+
+	req, err := d.client.newRequest(http.MethodPut, p, updateReq)
+	if err != nil {
+		return nil, fmt.Errorf("error creating http request: %w", err)
+	}
+
+	dataTopology := &DataTopology{}
+	if err := d.client.do(ctx, req, dataTopology); err != nil {
+		return nil, err
+	}
+
+	return dataTopology, nil
+}
diff --git a/internal/planetscale/data_topology_test.go b/internal/planetscale/data_topology_test.go
new file mode 100644
index 000000000..a2f68e9b3
--- /dev/null
+++ b/internal/planetscale/data_topology_test.go
@@ -0,0 +1,85 @@
+package planetscale
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestDatabaseBranches_DataTopology(t *testing.T) {
+	c := qt.New(t)
+
+	wantPath := "/v1/organizations/my-org/databases/my-db/branches/main/data-topology"
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		c.Assert(r.Method, qt.Equals, http.MethodGet)
+		c.Assert(r.URL.Path, qt.Equals, wantPath)
+		w.Header().Set("Content-Type", "application/json")
+		_, err := w.Write([]byte(`{"id":"topology-id","type":"NekiDataTopology","data_topology":{"authoritative_shard_group":"default"},"synced_at":"2026-08-03T12:00:00Z"}`))
+		c.Assert(err, qt.IsNil)
+	}))
+	t.Cleanup(ts.Close)
+
+	client, err := NewClient(WithBaseURL(ts.URL))
+	c.Assert(err, qt.IsNil)
+
+	dataTopology, err := client.DatabaseBranches.DataTopology(context.Background(), &BranchDataTopologyRequest{
+		Organization: "my-org",
+		Database:     "my-db",
+		Branch:       "main",
+	})
+	c.Assert(err, qt.IsNil)
+
+	syncedAt := time.Date(2026, time.August, 3, 12, 0, 0, 0, time.UTC)
+	c.Assert(dataTopology, qt.DeepEquals, &DataTopology{
+		ID:           "topology-id",
+		Type:         "NekiDataTopology",
+		DataTopology: json.RawMessage(`{"authoritative_shard_group":"default"}`),
+		SyncedAt:     &syncedAt,
+	})
+}
+
+func TestDatabaseBranches_UpdateDataTopology(t *testing.T) {
+	c := qt.New(t)
+
+	topology := json.RawMessage(`{"authoritative_shard_group":"default","shard_groups":[]}`)
+	wantPath := "/v1/organizations/my-org/databases/my-db/branches/main/data-topology"
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		c.Assert(r.Method, qt.Equals, http.MethodPut)
+		c.Assert(r.URL.Path, qt.Equals, wantPath)
+
+		var body struct {
+			DataTopology json.RawMessage `json:"data_topology"`
+		}
+		err := json.NewDecoder(r.Body).Decode(&body)
+		c.Assert(err, qt.IsNil)
+		c.Assert(string(body.DataTopology), qt.JSONEquals, map[string]any{
+			"authoritative_shard_group": "default",
+			"shard_groups":              []any{},
+		})
+
+		w.Header().Set("Content-Type", "application/json")
+		_, err = w.Write([]byte(`{"id":"topology-id","type":"NekiDataTopology","data_topology":{"authoritative_shard_group":"default","shard_groups":[]},"synced_at":null}`))
+		c.Assert(err, qt.IsNil)
+	}))
+	t.Cleanup(ts.Close)
+
+	client, err := NewClient(WithBaseURL(ts.URL))
+	c.Assert(err, qt.IsNil)
+
+	dataTopology, err := client.DatabaseBranches.UpdateDataTopology(context.Background(), &UpdateBranchDataTopologyRequest{
+		Organization: "my-org",
+		Database:     "my-db",
+		Branch:       "main",
+		DataTopology: topology,
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(string(dataTopology.DataTopology), qt.JSONEquals, map[string]any{
+		"authoritative_shard_group": "default",
+		"shard_groups":              []any{},
+	})
+}
diff --git a/internal/planetscale/databases.go b/internal/planetscale/databases.go
index 8d4f37add..b24203c3e 100644
--- a/internal/planetscale/databases.go
+++ b/internal/planetscale/databases.go
@@ -13,6 +13,7 @@ type DatabaseEngine string
 const (
 	DatabaseEngineMySQL    DatabaseEngine = "mysql"
 	DatabaseEnginePostgres DatabaseEngine = "postgresql"
+	DatabaseEngineNeki     DatabaseEngine = "neki"
 )
 
 // StorageConfig represents storage size configuration for a database or branch.
diff --git a/internal/planetscale/keyspaces.go b/internal/planetscale/keyspaces.go
index b56b8b673..1b78de6bf 100644
--- a/internal/planetscale/keyspaces.go
+++ b/internal/planetscale/keyspaces.go
@@ -25,15 +25,6 @@ type Keyspace struct {
 	VReplicationFlags                *VReplicationFlags                `json:"vreplication_flags"`
 	ReplicationDurabilityConstraints *ReplicationDurabilityConstraints `json:"replication_durability_constraints"`
 	ReadOnlyRegions                  []*ReadOnlyRegionKeyspace         `json:"read_only_regions"`
-	DiskAutoscaling                  *DiskAutoscaling                  `json:"disk_autoscaling"`
-}
-
-// DiskAutoscaling configures how a keyspace's dedicated disks autoscale.
-type DiskAutoscaling struct {
-	// Strategy is the disk autoscaling strategy: "grow" or "disable".
-	Strategy string `json:"strategy"`
-	// StorageLimitBytes is the maximum size in bytes disks may autoscale to.
-	StorageLimitBytes int64 `json:"storage_limit_bytes"`
 }
 
 type ReadOnlyRegionKeyspace struct {
@@ -183,14 +174,6 @@ type UpdateKeyspaceSettingsRequest struct {
 	Keyspace                         string                            `json:"-"`
 	ReplicationDurabilityConstraints *ReplicationDurabilityConstraints `json:"replication_durability_constraints,omitempty"`
 	VReplicationFlags                *VReplicationFlags                `json:"vreplication_flags,omitempty"`
-	DiskAutoscaling                  *DiskAutoscalingUpdate            `json:"disk_autoscaling,omitempty"`
-}
-
-// DiskAutoscalingUpdate is the request body for changing a keyspace's disk
-// autoscaling settings. Only the fields that are set are sent to the API.
-type DiskAutoscalingUpdate struct {
-	Strategy          *string `json:"strategy,omitempty"`
-	StorageLimitBytes *int64  `json:"storage_limit_bytes,omitempty"`
 }
 
 type ReplicationDurabilityConstraints struct {
diff --git a/internal/planetscale/keyspaces_test.go b/internal/planetscale/keyspaces_test.go
index 45166dd50..792ec3974 100644
--- a/internal/planetscale/keyspaces_test.go
+++ b/internal/planetscale/keyspaces_test.go
@@ -3,7 +3,6 @@ package planetscale
 import (
 	"context"
 	"encoding/json"
-	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -480,45 +479,3 @@ func TestKeyspaces_UpdateSettings(t *testing.T) {
 	c.Assert(keyspace.VReplicationFlags.VPlayerBatching, qt.Equals, true)
 	c.Assert(keyspace.ReplicationDurabilityConstraints.Strategy, qt.Equals, "maximum")
 }
-
-func TestKeyspaces_UpdateSettingsDiskAutoscaling(t *testing.T) {
-	c := qt.New(t)
-
-	var body []byte
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		var err error
-		body, err = io.ReadAll(r.Body)
-		c.Assert(err, qt.IsNil)
-
-		w.WriteHeader(200)
-		out := `{"type":"Keyspace","id":"thisisanid","name":"planetscale","shards":2,"sharded":true,"disk_autoscaling":{"strategy":"grow","storage_limit_bytes":8796093022208}}`
-		_, err = w.Write([]byte(out))
-		c.Assert(err, qt.IsNil)
-		c.Assert(r.Method, qt.Equals, http.MethodPatch)
-	}))
-
-	client, err := NewClient(WithBaseURL(ts.URL))
-	c.Assert(err, qt.IsNil)
-
-	ctx := context.Background()
-
-	strategy := "grow"
-	limit := int64(8796093022208)
-
-	keyspace, err := client.Keyspaces.UpdateSettings(ctx, &UpdateKeyspaceSettingsRequest{
-		Organization: "foo",
-		Database:     "bar",
-		Branch:       "baz",
-		Keyspace:     "qux",
-		DiskAutoscaling: &DiskAutoscalingUpdate{
-			Strategy:          &strategy,
-			StorageLimitBytes: &limit,
-		},
-	})
-
-	c.Assert(err, qt.IsNil)
-	c.Assert(string(body), qt.Contains, `"disk_autoscaling":{"strategy":"grow","storage_limit_bytes":8796093022208}`)
-	c.Assert(keyspace.DiskAutoscaling, qt.IsNotNil)
-	c.Assert(keyspace.DiskAutoscaling.Strategy, qt.Equals, "grow")
-	c.Assert(keyspace.DiskAutoscaling.StorageLimitBytes, qt.Equals, int64(8796093022208))
-}
diff --git a/internal/planetscale/logs.go b/internal/planetscale/logs.go
new file mode 100644
index 000000000..142e27fb6
--- /dev/null
+++ b/internal/planetscale/logs.go
@@ -0,0 +1,108 @@
+package planetscale
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"path"
+
+	"github.com/hashicorp/go-cleanhttp"
+)
+
+// LogSignature contains the signed URL and credentials used to query a
+// branch's logs.
+type LogSignature struct {
+	Signature string `json:"sig"`
+	ExpiresAt string `json:"exp"`
+	URL       string `json:"url"`
+}
+
+// CreateLogSignatureRequest identifies the branch whose logs will be queried.
+type CreateLogSignatureRequest struct {
+	Organization string
+	Database     string
+	Branch       string
+}
+
+// QueryLogsRequest contains a signed logs URL and the query parameters to add
+// to it.
+type QueryLogsRequest struct {
+	URL   string
+	Query string
+	Limit int
+}
+
+// LogsService communicates with the branch log-signature endpoint and the
+// signed logs endpoint.
+type LogsService interface {
+	CreateSignature(context.Context, *CreateLogSignatureRequest) (*LogSignature, error)
+	Query(context.Context, *QueryLogsRequest) (io.ReadCloser, error)
+}
+
+type logsService struct {
+	client *Client
+}
+
+var _ LogsService = &logsService{}
+
+// NewLogsService creates a service for querying branch logs.
+func NewLogsService(client *Client) *logsService {
+	return &logsService{client: client}
+}
+
+// CreateSignature returns a signed branch logs URL.
+func (s *logsService) CreateSignature(ctx context.Context, createReq *CreateLogSignatureRequest) (*LogSignature, error) {
+	reqPath := path.Join(databaseBranchAPIPath(createReq.Organization, createReq.Database, createReq.Branch), "logs/signatures")
+	req, err := s.client.newRequest(http.MethodPost, reqPath, nil)
+	if err != nil {
+		return nil, fmt.Errorf("creating log signature request: %w", err)
+	}
+
+	signature := &LogSignature{}
+	if err := s.client.do(ctx, req, signature); err != nil {
+		return nil, err
+	}
+
+	return signature, nil
+}
+
+// Query fetches logs from a signed URL. It deliberately uses an
+// unauthenticated HTTP client so PlanetScale API credentials are never sent to
+// the logs host.
+func (s *logsService) Query(ctx context.Context, queryReq *QueryLogsRequest) (io.ReadCloser, error) {
+	u, err := url.Parse(queryReq.URL)
+	if err != nil {
+		return nil, fmt.Errorf("parsing signed logs URL: %w", err)
+	}
+	if !u.IsAbs() || u.Host == "" {
+		return nil, fmt.Errorf("parsing signed logs URL: URL must be absolute")
+	}
+
+	query := u.Query()
+	query.Set("limit", fmt.Sprintf("%d", queryReq.Limit))
+	query.Set("query", queryReq.Query)
+	u.RawQuery = query.Encode()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
+	if err != nil {
+		return nil, fmt.Errorf("creating logs query request: %w", err)
+	}
+	req.Header.Set("User-Agent", s.client.UserAgent)
+
+	res, err := cleanhttp.DefaultClient().Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("querying branch logs: %w", err)
+	}
+	if res.StatusCode >= http.StatusMultipleChoices {
+		defer res.Body.Close()
+		body, readErr := io.ReadAll(io.LimitReader(res.Body, 4096))
+		if readErr != nil {
+			return nil, fmt.Errorf("querying branch logs: HTTP %s", res.Status)
+		}
+		return nil, fmt.Errorf("querying branch logs: HTTP %s: %s", res.Status, bodySnippet(body))
+	}
+
+	return res.Body, nil
+}
diff --git a/internal/planetscale/logs_test.go b/internal/planetscale/logs_test.go
new file mode 100644
index 000000000..1ca944133
--- /dev/null
+++ b/internal/planetscale/logs_test.go
@@ -0,0 +1,107 @@
+package planetscale
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestLogsServiceCreatesSignatureAndQueriesSignedURLWithoutCredentials(t *testing.T) {
+	var serverURL string
+	mux := http.NewServeMux()
+	mux.HandleFunc("/v1/organizations/acme/databases/db/branches/main/logs/signatures", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			t.Fatalf("signature method = %s, want POST", r.Method)
+		}
+		if got := r.Header.Get("Authorization"); got != "Bearer api-token" {
+			t.Fatalf("signature authorization = %q, want Bearer api-token", got)
+		}
+		_ = json.NewEncoder(w).Encode(map[string]string{
+			"sig": "signed",
+			"exp": "12345",
+			"url": serverURL + "/signed?sig=signed&exp=12345",
+		})
+	})
+	mux.HandleFunc("/signed", func(w http.ResponseWriter, r *http.Request) {
+		if got := r.Header.Get("Authorization"); got != "" {
+			t.Fatalf("signed logs request leaked authorization header %q", got)
+		}
+		if got := r.URL.Query().Get("sig"); got != "signed" {
+			t.Fatalf("sig = %q, want signed", got)
+		}
+		if got := r.URL.Query().Get("exp"); got != "12345" {
+			t.Fatalf("exp = %q, want 12345", got)
+		}
+		if got := r.URL.Query().Get("limit"); got != "25" {
+			t.Fatalf("limit = %q, want 25", got)
+		}
+		if got := r.URL.Query().Get("query"); got != "* _time:1h" {
+			t.Fatalf("query = %q, want %q", got, "* _time:1h")
+		}
+		_, _ = io.WriteString(w, "log response")
+	})
+
+	server := httptest.NewServer(mux)
+	serverURL = server.URL
+	t.Cleanup(server.Close)
+
+	client, err := NewClient(WithBaseURL(server.URL), WithAccessToken("api-token"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	signature, err := client.Logs.CreateSignature(context.Background(), &CreateLogSignatureRequest{
+		Organization: "acme",
+		Database:     "db",
+		Branch:       "main",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if signature.Signature != "signed" || signature.ExpiresAt != "12345" {
+		t.Fatalf("unexpected signature: %#v", signature)
+	}
+
+	body, err := client.Logs.Query(context.Background(), &QueryLogsRequest{
+		URL:   signature.URL,
+		Query: "* _time:1h",
+		Limit: 25,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer body.Close()
+
+	got, err := io.ReadAll(body)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(got) != "log response" {
+		t.Fatalf("body = %q, want log response", got)
+	}
+}
+
+func TestLogsServiceQueryErrorIncludesStatusAndShortBody(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusBadGateway)
+		_, _ = io.WriteString(w, "logs temporarily unavailable")
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := NewClient()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = client.Logs.Query(context.Background(), &QueryLogsRequest{URL: server.URL, Query: "*", Limit: 100})
+	if err == nil {
+		t.Fatal("expected query error")
+	}
+	want := "HTTP 502 Bad Gateway: logs temporarily unavailable"
+	if got := err.Error(); got != "querying branch logs: "+want {
+		t.Fatalf("error = %q, want %q", got, "querying branch logs: "+want)
+	}
+}
diff --git a/internal/planetscale/neki_admins.go b/internal/planetscale/neki_admins.go
new file mode 100644
index 000000000..be42d1f83
--- /dev/null
+++ b/internal/planetscale/neki_admins.go
@@ -0,0 +1,204 @@
+package planetscale
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"path"
+	"time"
+)
+
+// NekiAdminSKU represents the size of a Neki admin.
+type NekiAdminSKU struct {
+	Name        string `json:"name"`
+	DisplayName string `json:"display_name"`
+	CPU         string `json:"cpu"`
+	RAM         int64  `json:"ram"`
+	SortOrder   int    `json:"sort_order"`
+}
+
+// NekiAdmin represents the failover and recovery admin for a Neki cluster.
+type NekiAdmin struct {
+	Type      string        `json:"type,omitempty"`
+	ID        string        `json:"id"`
+	SKU       *NekiAdminSKU `json:"sku,omitempty"`
+	AdminSize string        `json:"admin_size"`
+	State     string        `json:"state"`
+	CreatedAt time.Time     `json:"created_at"`
+	UpdatedAt time.Time     `json:"updated_at"`
+}
+
+type GetNekiAdminRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+}
+
+type UpdateNekiAdminRequest struct {
+	Organization string                       `json:"-"`
+	Database     string                       `json:"-"`
+	Branch       string                       `json:"-"`
+	AdminSize    *string                      `json:"admin_size,omitempty"`
+	Parameters   map[string]map[string]string `json:"parameters,omitempty"`
+}
+
+type ListNekiAdminParametersRequest = GetNekiAdminRequest
+
+type ListNekiAdminSizeSKUsRequest = GetNekiAdminRequest
+
+type NekiAdminChange struct {
+	Type                         string                       `json:"type,omitempty"`
+	ID                           string                       `json:"id"`
+	State                        string                       `json:"state"`
+	StartedAt                    *time.Time                   `json:"started_at"`
+	CompletedAt                  *time.Time                   `json:"completed_at"`
+	CreatedAt                    time.Time                    `json:"created_at"`
+	UpdatedAt                    time.Time                    `json:"updated_at"`
+	AdminSize                    string                       `json:"admin_size"`
+	AdminSizeDisplayName         string                       `json:"admin_size_display_name"`
+	PreviousAdminSize            string                       `json:"previous_admin_size"`
+	PreviousAdminSizeDisplayName string                       `json:"previous_admin_size_display_name"`
+	Parameters                   map[string]map[string]string `json:"parameters"`
+	PreviousParameters           map[string]map[string]string `json:"previous_parameters"`
+	Actor                        *Actor                       `json:"actor,omitempty"`
+}
+
+type ListNekiAdminChangesRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Period       string `json:"-"`
+	CompletedAt  string `json:"-"`
+	Page         int    `json:"-"`
+	PerPage      int    `json:"-"`
+}
+
+type GetNekiAdminChangeRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Change       string `json:"-"`
+}
+
+type CancelNekiAdminChangeRequest = GetNekiAdminChangeRequest
+
+type nekiAdminChangesResponse struct {
+	Changes []*NekiAdminChange `json:"data"`
+}
+
+// NekiAdminsService manages the admin belonging to a Neki branch.
+// The admin is created and deleted with the cluster; this service exposes
+// get and update only.
+type NekiAdminsService interface {
+	Get(context.Context, *GetNekiAdminRequest) (*NekiAdmin, error)
+	Update(context.Context, *UpdateNekiAdminRequest) (*NekiAdmin, error)
+	ListParameters(context.Context, *ListNekiAdminParametersRequest) ([]*NekiParameter, error)
+	ListSizeSKUs(context.Context, *ListNekiAdminSizeSKUsRequest) ([]*NekiAdminSKU, error)
+	ListChanges(context.Context, *ListNekiAdminChangesRequest) ([]*NekiAdminChange, error)
+	GetChange(context.Context, *GetNekiAdminChangeRequest) (*NekiAdminChange, error)
+	CancelChange(context.Context, *CancelNekiAdminChangeRequest) error
+}
+
+type nekiAdminsService struct{ client *Client }
+
+var _ NekiAdminsService = &nekiAdminsService{}
+
+func (s *nekiAdminsService) Get(ctx context.Context, r *GetNekiAdminRequest) (*NekiAdmin, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiAdminAPIPath(r.Organization, r.Database, r.Branch), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to get admin: %w", err)
+	}
+	admin := &NekiAdmin{}
+	if err := s.client.do(ctx, request, admin); err != nil {
+		return nil, err
+	}
+	return admin, nil
+}
+
+func (s *nekiAdminsService) Update(ctx context.Context, r *UpdateNekiAdminRequest) (*NekiAdmin, error) {
+	request, err := s.client.newRequest(http.MethodPatch, nekiAdminAPIPath(r.Organization, r.Database, r.Branch), r)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to update admin: %w", err)
+	}
+	admin := &NekiAdmin{}
+	if err := s.client.do(ctx, request, admin); err != nil {
+		return nil, err
+	}
+	return admin, nil
+}
+
+func (s *nekiAdminsService) ListSizeSKUs(ctx context.Context, r *ListNekiAdminSizeSKUsRequest) ([]*NekiAdminSKU, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiAdminSizeSKUsAPIPath(r.Organization, r.Database, r.Branch), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list admin size SKUs: %w", err)
+	}
+	skus := []*NekiAdminSKU{}
+	if err := s.client.do(ctx, request, &skus); err != nil {
+		return nil, err
+	}
+	return skus, nil
+}
+
+func (s *nekiAdminsService) ListParameters(ctx context.Context, r *ListNekiAdminParametersRequest) ([]*NekiParameter, error) {
+	request, err := s.client.newRequest(http.MethodGet, path.Join(nekiAdminAPIPath(r.Organization, r.Database, r.Branch), "parameters"), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list admin parameters: %w", err)
+	}
+	parameters := []*NekiParameter{}
+	if err := s.client.do(ctx, request, &parameters); err != nil {
+		return nil, err
+	}
+	return parameters, nil
+}
+
+func (s *nekiAdminsService) ListChanges(ctx context.Context, r *ListNekiAdminChangesRequest) ([]*NekiAdminChange, error) {
+	values := defaultListOptions(WithPeriod(r.Period), WithPage(r.Page), WithPerPage(r.PerPage))
+	if r.CompletedAt != "" {
+		values.URLValues.Set("completed_at", r.CompletedAt)
+	}
+	request, err := s.client.newRequest(http.MethodGet, nekiAdminChangesAPIPath(r.Organization, r.Database, r.Branch), nil, WithQueryParams(*values.URLValues))
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list admin changes: %w", err)
+	}
+	response := &nekiAdminChangesResponse{}
+	if err := s.client.do(ctx, request, response); err != nil {
+		return nil, err
+	}
+	return response.Changes, nil
+}
+
+func (s *nekiAdminsService) GetChange(ctx context.Context, r *GetNekiAdminChangeRequest) (*NekiAdminChange, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiAdminChangeAPIPath(r.Organization, r.Database, r.Branch, r.Change), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to get admin change: %w", err)
+	}
+	change := &NekiAdminChange{}
+	if err := s.client.do(ctx, request, change); err != nil {
+		return nil, err
+	}
+	return change, nil
+}
+
+func (s *nekiAdminsService) CancelChange(ctx context.Context, r *CancelNekiAdminChangeRequest) error {
+	request, err := s.client.newRequest(http.MethodDelete, nekiAdminChangeAPIPath(r.Organization, r.Database, r.Branch, r.Change), nil)
+	if err != nil {
+		return fmt.Errorf("error creating request to cancel admin change: %w", err)
+	}
+	return s.client.do(ctx, request, nil)
+}
+
+func nekiAdminSizeSKUsAPIPath(org, database, branch string) string {
+	return path.Join(databaseBranchAPIPath(org, database, branch), "admin-size-skus")
+}
+
+func nekiAdminAPIPath(org, database, branch string) string {
+	return path.Join(databaseBranchAPIPath(org, database, branch), "admin")
+}
+
+func nekiAdminChangesAPIPath(org, database, branch string) string {
+	return path.Join(nekiAdminAPIPath(org, database, branch), "changes")
+}
+
+func nekiAdminChangeAPIPath(org, database, branch, change string) string {
+	return path.Join(nekiAdminChangesAPIPath(org, database, branch), change)
+}
diff --git a/internal/planetscale/neki_admins_test.go b/internal/planetscale/neki_admins_test.go
new file mode 100644
index 000000000..1afe6a55f
--- /dev/null
+++ b/internal/planetscale/neki_admins_test.go
@@ -0,0 +1,118 @@
+package planetscale
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestNekiAdminsService(t *testing.T) {
+	c := qt.New(t)
+	const basePath = "/v1/organizations/acme/databases/app/branches/main"
+	const adminPath = basePath + "/admin"
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		writeAdmin := func() {
+			_, _ = w.Write([]byte(`{"type":"NekiAdmin","id":"admin-1","admin_size":"NKA_0","sku":{"name":"NKA_0","display_name":"NKA-0"},"state":"ready","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z"}`))
+		}
+
+		switch {
+		case r.Method == http.MethodGet && r.URL.Path == adminPath:
+			writeAdmin()
+
+		case r.Method == http.MethodPatch && r.URL.Path == adminPath:
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			c.Assert(body, qt.DeepEquals, map[string]interface{}{
+				"admin_size": "NKA_1",
+				"parameters": map[string]interface{}{"admin": map[string]interface{}{"recovery-poll-interval": "20s"}},
+			})
+			_, _ = w.Write([]byte(`{"type":"NekiAdmin","id":"admin-1","admin_size":"NKA_1","sku":{"name":"NKA_1","display_name":"NKA-1"},"state":"updating","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-05T12:00:00Z"}`))
+
+		case r.Method == http.MethodGet && r.URL.Path == basePath+"/admin-size-skus":
+			_, _ = w.Write([]byte(`[{"name":"NKA_0","display_name":"NKA-0","cpu":"0.5","ram":1073741824,"sort_order":1}]`))
+
+		case r.Method == http.MethodGet && r.URL.Path == adminPath+"/parameters":
+			_, _ = w.Write([]byte(`[{"name":"recovery-poll-interval","display_name":"Recovery poll interval","namespace":"admin","advanced":false,"category":null,"description":"How often the admin runs recovery analysis and repairs.","parameter_type":"time","default_value":"10s","value":"20s","required":false,"created_at":"2026-08-04T12:00:00Z","updated_at":null,"restart":false,"url":"https://example.test/parameter"}]`))
+
+		case r.Method == http.MethodGet && r.URL.Path == adminPath+"/changes":
+			c.Assert(r.URL.Query().Get("period"), qt.Equals, "24h")
+			c.Assert(r.URL.Query().Get("completed_at"), qt.Equals, "2026-08-04")
+			c.Assert(r.URL.Query().Get("page"), qt.Equals, "2")
+			c.Assert(r.URL.Query().Get("per_page"), qt.Equals, "25")
+			_, _ = w.Write([]byte(`{"data":[{"id":"change-1","state":"pending","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z","admin_size":"NKA_1","admin_size_display_name":"NKA-1","previous_admin_size":"NKA_0","previous_admin_size_display_name":"NKA-0","parameters":{"admin":{"recovery-poll-interval":"20s"}},"previous_parameters":{"admin":{"recovery-poll-interval":"10s"}}}]}`))
+
+		case r.Method == http.MethodGet && r.URL.Path == adminPath+"/changes/change-1":
+			_, _ = w.Write([]byte(`{"id":"change-1","state":"pending","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z","admin_size":"NKA_1","admin_size_display_name":"NKA-1","previous_admin_size":"NKA_0","previous_admin_size_display_name":"NKA-0","parameters":{"admin":{"recovery-poll-interval":"20s"}},"previous_parameters":{"admin":{"recovery-poll-interval":"10s"}}}`))
+
+		case r.Method == http.MethodDelete && r.URL.Path == adminPath+"/changes/change-1":
+			w.WriteHeader(http.StatusNoContent)
+
+		case r.Method == http.MethodPost && r.URL.Path == adminPath:
+			http.Error(w, "admin cannot be created", http.StatusMethodNotAllowed)
+
+		case r.Method == http.MethodDelete && r.URL.Path == adminPath:
+			http.Error(w, "admin cannot be deleted", http.StatusMethodNotAllowed)
+
+		default:
+			http.Error(w, "unexpected request", http.StatusNotFound)
+		}
+	}))
+	defer ts.Close()
+
+	client, err := NewClient(WithBaseURL(ts.URL))
+	c.Assert(err, qt.IsNil)
+	ctx := context.Background()
+
+	admin, err := client.NekiAdmins.Get(ctx, &GetNekiAdminRequest{Organization: "acme", Database: "app", Branch: "main"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(admin.ID, qt.Equals, "admin-1")
+	c.Assert(admin.AdminSize, qt.Equals, "NKA_0")
+	c.Assert(admin.SKU.DisplayName, qt.Equals, "NKA-0")
+	c.Assert(admin.State, qt.Equals, "ready")
+
+	size := "NKA_1"
+	admin, err = client.NekiAdmins.Update(ctx, &UpdateNekiAdminRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		AdminSize:    &size,
+		Parameters:   map[string]map[string]string{"admin": {"recovery-poll-interval": "20s"}},
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(admin.AdminSize, qt.Equals, "NKA_1")
+	c.Assert(admin.SKU.DisplayName, qt.Equals, "NKA-1")
+	c.Assert(admin.State, qt.Equals, "updating")
+
+	skus, err := client.NekiAdmins.ListSizeSKUs(ctx, &ListNekiAdminSizeSKUsRequest{Organization: "acme", Database: "app", Branch: "main"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(skus, qt.HasLen, 1)
+	c.Assert(skus[0].Name, qt.Equals, "NKA_0")
+	c.Assert(skus[0].DisplayName, qt.Equals, "NKA-0")
+
+	parameters, err := client.NekiAdmins.ListParameters(ctx, &ListNekiAdminParametersRequest{Organization: "acme", Database: "app", Branch: "main"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(parameters, qt.HasLen, 1)
+	c.Assert(parameters[0].Name, qt.Equals, "recovery-poll-interval")
+	c.Assert(parameters[0].Namespace, qt.Equals, "admin")
+	c.Assert(parameters[0].Value, qt.Equals, "20s")
+
+	changes, err := client.NekiAdmins.ListChanges(ctx, &ListNekiAdminChangesRequest{Organization: "acme", Database: "app", Branch: "main", Period: "24h", CompletedAt: "2026-08-04", Page: 2, PerPage: 25})
+	c.Assert(err, qt.IsNil)
+	c.Assert(changes, qt.HasLen, 1)
+	c.Assert(changes[0].ID, qt.Equals, "change-1")
+	c.Assert(changes[0].AdminSize, qt.Equals, "NKA_1")
+	c.Assert(changes[0].AdminSizeDisplayName, qt.Equals, "NKA-1")
+	c.Assert(changes[0].PreviousAdminSize, qt.Equals, "NKA_0")
+
+	change, err := client.NekiAdmins.GetChange(ctx, &GetNekiAdminChangeRequest{Organization: "acme", Database: "app", Branch: "main", Change: "change-1"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(change.State, qt.Equals, "pending")
+
+	err = client.NekiAdmins.CancelChange(ctx, &CancelNekiAdminChangeRequest{Organization: "acme", Database: "app", Branch: "main", Change: "change-1"})
+	c.Assert(err, qt.IsNil)
+}
diff --git a/internal/planetscale/neki_routers.go b/internal/planetscale/neki_routers.go
new file mode 100644
index 000000000..9b0aca747
--- /dev/null
+++ b/internal/planetscale/neki_routers.go
@@ -0,0 +1,300 @@
+package planetscale
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"path"
+	"time"
+)
+
+// NekiRouterSKU represents the size of a Neki router.
+type NekiRouterSKU struct {
+	Name        string `json:"name"`
+	DisplayName string `json:"display_name"`
+	CPU         string `json:"cpu"`
+	RAM         int64  `json:"ram"`
+	SortOrder   int    `json:"sort_order"`
+	Rate        *int64 `json:"rate,omitempty"`
+}
+
+// NekiRouter represents a router group for a Neki branch.
+type NekiRouter struct {
+	Type                 string         `json:"type,omitempty"`
+	Name                 string         `json:"name"`
+	Default              bool           `json:"default"`
+	SKU                  *NekiRouterSKU `json:"sku,omitempty"`
+	ReplicasPerCell      int            `json:"replicas_per_cell"`
+	Autoscaling          bool           `json:"autoscaling"`
+	MaxReplicasPerCell   *int           `json:"max_replicas_per_cell"`
+	TargetCPUUtilization *int           `json:"target_cpu_utilization"`
+	State                string         `json:"state"`
+	CreatedAt            time.Time      `json:"created_at"`
+	UpdatedAt            time.Time      `json:"updated_at"`
+}
+
+type ListNekiRoutersRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+}
+
+type GetNekiRouterRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Router       string `json:"-"`
+}
+
+type CreateNekiRouterRequest struct {
+	Organization    string `json:"-"`
+	Database        string `json:"-"`
+	Branch          string `json:"-"`
+	Name            string `json:"name"`
+	RouterSize      string `json:"router_size,omitempty"`
+	ReplicasPerCell *int   `json:"replicas_per_cell,omitempty"`
+}
+
+// UpdateNekiRouterRequest changes a router through the change-request flow;
+// only set fields are sent.
+type UpdateNekiRouterRequest struct {
+	Organization         string                       `json:"-"`
+	Database             string                       `json:"-"`
+	Branch               string                       `json:"-"`
+	Router               string                       `json:"-"`
+	RouterSize           *string                      `json:"router_size,omitempty"`
+	ReplicasPerCell      *int                         `json:"replicas_per_cell,omitempty"`
+	Autoscaling          *bool                        `json:"autoscaling,omitempty"`
+	MaxReplicasPerCell   *int                         `json:"max_replicas_per_cell,omitempty"`
+	TargetCPUUtilization *int                         `json:"target_cpu_utilization,omitempty"`
+	Parameters           map[string]map[string]string `json:"parameters,omitempty"`
+}
+
+type DeleteNekiRouterRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Router       string `json:"-"`
+}
+
+type ListNekiRouterParametersRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Router       string `json:"-"`
+}
+
+type ListNekiRouterSizeSKUsRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Rates        bool   `json:"-"`
+}
+
+type NekiRouterChange struct {
+	Type                          string                       `json:"type,omitempty"`
+	ID                            string                       `json:"id"`
+	State                         string                       `json:"state"`
+	StartedAt                     *time.Time                   `json:"started_at"`
+	CompletedAt                   *time.Time                   `json:"completed_at"`
+	CreatedAt                     time.Time                    `json:"created_at"`
+	UpdatedAt                     time.Time                    `json:"updated_at"`
+	RouterSize                    string                       `json:"router_size"`
+	RouterSizeDisplayName         string                       `json:"router_size_display_name"`
+	ReplicasPerCell               int                          `json:"replicas_per_cell"`
+	Autoscaling                   *bool                        `json:"autoscaling"`
+	MaxReplicasPerCell            *int                         `json:"max_replicas_per_cell"`
+	TargetCPUUtilization          *int                         `json:"target_cpu_utilization"`
+	Parameters                    map[string]map[string]string `json:"parameters"`
+	PreviousRouterSize            string                       `json:"previous_router_size"`
+	PreviousRouterSizeDisplayName string                       `json:"previous_router_size_display_name"`
+	PreviousReplicasPerCell       int                          `json:"previous_replicas_per_cell"`
+	PreviousAutoscaling           *bool                        `json:"previous_autoscaling"`
+	PreviousMaxReplicasPerCell    *int                         `json:"previous_max_replicas_per_cell"`
+	PreviousTargetCPUUtilization  *int                         `json:"previous_target_cpu_utilization"`
+	PreviousParameters            map[string]map[string]string `json:"previous_parameters"`
+	Actor                         *Actor                       `json:"actor,omitempty"`
+}
+
+type ListNekiRouterChangesRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Router       string `json:"-"`
+	Period       string `json:"-"`
+	CompletedAt  string `json:"-"`
+	Page         int    `json:"-"`
+	PerPage      int    `json:"-"`
+}
+
+type GetNekiRouterChangeRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Router       string `json:"-"`
+	Change       string `json:"-"`
+}
+
+type CancelNekiRouterChangeRequest = GetNekiRouterChangeRequest
+
+type nekiRouterChangesResponse struct {
+	Changes []*NekiRouterChange `json:"data"`
+}
+
+// NekiRoutersService manages router groups belonging to Neki branches.
+type NekiRoutersService interface {
+	List(context.Context, *ListNekiRoutersRequest) ([]*NekiRouter, error)
+	Get(context.Context, *GetNekiRouterRequest) (*NekiRouter, error)
+	Create(context.Context, *CreateNekiRouterRequest) (*NekiRouter, error)
+	Update(context.Context, *UpdateNekiRouterRequest) (*NekiRouter, error)
+	Delete(context.Context, *DeleteNekiRouterRequest) error
+	ListParameters(context.Context, *ListNekiRouterParametersRequest) ([]*NekiParameter, error)
+	ListSizeSKUs(context.Context, *ListNekiRouterSizeSKUsRequest) ([]*NekiRouterSKU, error)
+	ListChanges(context.Context, *ListNekiRouterChangesRequest) ([]*NekiRouterChange, error)
+	GetChange(context.Context, *GetNekiRouterChangeRequest) (*NekiRouterChange, error)
+	CancelChange(context.Context, *CancelNekiRouterChangeRequest) error
+}
+
+type nekiRoutersService struct{ client *Client }
+
+var _ NekiRoutersService = &nekiRoutersService{}
+
+func (s *nekiRoutersService) List(ctx context.Context, r *ListNekiRoutersRequest) ([]*NekiRouter, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiRoutersAPIPath(r.Organization, r.Database, r.Branch), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list routers: %w", err)
+	}
+	routers := []*NekiRouter{}
+	if err := s.client.do(ctx, request, &routers); err != nil {
+		return nil, err
+	}
+	return routers, nil
+}
+
+func (s *nekiRoutersService) Get(ctx context.Context, r *GetNekiRouterRequest) (*NekiRouter, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiRouterAPIPath(r.Organization, r.Database, r.Branch, r.Router), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to get router: %w", err)
+	}
+	router := &NekiRouter{}
+	if err := s.client.do(ctx, request, router); err != nil {
+		return nil, err
+	}
+	return router, nil
+}
+
+func (s *nekiRoutersService) Create(ctx context.Context, r *CreateNekiRouterRequest) (*NekiRouter, error) {
+	request, err := s.client.newRequest(http.MethodPost, nekiRoutersAPIPath(r.Organization, r.Database, r.Branch), r)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to create router: %w", err)
+	}
+	router := &NekiRouter{}
+	if err := s.client.do(ctx, request, router); err != nil {
+		return nil, err
+	}
+	return router, nil
+}
+
+func (s *nekiRoutersService) Update(ctx context.Context, r *UpdateNekiRouterRequest) (*NekiRouter, error) {
+	request, err := s.client.newRequest(http.MethodPatch, nekiRouterAPIPath(r.Organization, r.Database, r.Branch, r.Router), r)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to update router: %w", err)
+	}
+	router := &NekiRouter{}
+	if err := s.client.do(ctx, request, router); err != nil {
+		return nil, err
+	}
+	return router, nil
+}
+
+func (s *nekiRoutersService) Delete(ctx context.Context, r *DeleteNekiRouterRequest) error {
+	request, err := s.client.newRequest(http.MethodDelete, nekiRouterAPIPath(r.Organization, r.Database, r.Branch, r.Router), nil)
+	if err != nil {
+		return fmt.Errorf("error creating request to delete router: %w", err)
+	}
+	return s.client.do(ctx, request, nil)
+}
+
+func (s *nekiRoutersService) ListSizeSKUs(ctx context.Context, r *ListNekiRouterSizeSKUsRequest) ([]*NekiRouterSKU, error) {
+	opts := []RequestOption{}
+	if r.Rates {
+		opts = append(opts, WithQueryParams(*defaultListOptions(WithRates()).URLValues))
+	}
+	request, err := s.client.newRequest(http.MethodGet, nekiRouterSizeSKUsAPIPath(r.Organization, r.Database, r.Branch), nil, opts...)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list router size SKUs: %w", err)
+	}
+	skus := []*NekiRouterSKU{}
+	if err := s.client.do(ctx, request, &skus); err != nil {
+		return nil, err
+	}
+	return skus, nil
+}
+
+func (s *nekiRoutersService) ListParameters(ctx context.Context, r *ListNekiRouterParametersRequest) ([]*NekiParameter, error) {
+	request, err := s.client.newRequest(http.MethodGet, path.Join(nekiRouterAPIPath(r.Organization, r.Database, r.Branch, r.Router), "parameters"), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list router parameters: %w", err)
+	}
+	parameters := []*NekiParameter{}
+	if err := s.client.do(ctx, request, &parameters); err != nil {
+		return nil, err
+	}
+	return parameters, nil
+}
+
+func (s *nekiRoutersService) ListChanges(ctx context.Context, r *ListNekiRouterChangesRequest) ([]*NekiRouterChange, error) {
+	values := defaultListOptions(WithPeriod(r.Period), WithPage(r.Page), WithPerPage(r.PerPage))
+	if r.CompletedAt != "" {
+		values.URLValues.Set("completed_at", r.CompletedAt)
+	}
+	request, err := s.client.newRequest(http.MethodGet, nekiRouterChangesAPIPath(r.Organization, r.Database, r.Branch, r.Router), nil, WithQueryParams(*values.URLValues))
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list router changes: %w", err)
+	}
+	response := &nekiRouterChangesResponse{}
+	if err := s.client.do(ctx, request, response); err != nil {
+		return nil, err
+	}
+	return response.Changes, nil
+}
+
+func (s *nekiRoutersService) GetChange(ctx context.Context, r *GetNekiRouterChangeRequest) (*NekiRouterChange, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiRouterChangeAPIPath(r.Organization, r.Database, r.Branch, r.Router, r.Change), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to get router change: %w", err)
+	}
+	change := &NekiRouterChange{}
+	if err := s.client.do(ctx, request, change); err != nil {
+		return nil, err
+	}
+	return change, nil
+}
+
+func (s *nekiRoutersService) CancelChange(ctx context.Context, r *CancelNekiRouterChangeRequest) error {
+	request, err := s.client.newRequest(http.MethodDelete, nekiRouterChangeAPIPath(r.Organization, r.Database, r.Branch, r.Router, r.Change), nil)
+	if err != nil {
+		return fmt.Errorf("error creating request to cancel router change: %w", err)
+	}
+	return s.client.do(ctx, request, nil)
+}
+
+func nekiRouterSizeSKUsAPIPath(org, database, branch string) string {
+	return path.Join(databaseBranchAPIPath(org, database, branch), "router-size-skus")
+}
+
+func nekiRoutersAPIPath(org, database, branch string) string {
+	return path.Join(databaseBranchAPIPath(org, database, branch), "routers")
+}
+
+func nekiRouterAPIPath(org, database, branch, router string) string {
+	return path.Join(nekiRoutersAPIPath(org, database, branch), router)
+}
+
+func nekiRouterChangesAPIPath(org, database, branch, router string) string {
+	return path.Join(nekiRouterAPIPath(org, database, branch, router), "changes")
+}
+
+func nekiRouterChangeAPIPath(org, database, branch, router, change string) string {
+	return path.Join(nekiRouterChangesAPIPath(org, database, branch, router), change)
+}
diff --git a/internal/planetscale/neki_routers_test.go b/internal/planetscale/neki_routers_test.go
new file mode 100644
index 000000000..12317c2b4
--- /dev/null
+++ b/internal/planetscale/neki_routers_test.go
@@ -0,0 +1,269 @@
+package planetscale
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestNekiRoutersService(t *testing.T) {
+	c := qt.New(t)
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.Method == http.MethodGet && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/routers":
+			_, _ = w.Write([]byte(`[{
+				"type":"neki_router",
+				"name":"default",
+				"default":true,
+				"sku":{"name":"NKR_5","display_name":"NKR-5","cpu":"1","ram":4294967296,"sort_order":1},
+				"replicas_per_cell":1,
+				"autoscaling":false,
+				"max_replicas_per_cell":null,
+				"target_cpu_utilization":null,
+				"state":"ready",
+				"created_at":"2026-08-04T12:00:00Z",
+				"updated_at":"2026-08-04T12:00:00Z"
+			}]`))
+
+		case r.Method == http.MethodGet && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/routers/analytics":
+			_, _ = w.Write([]byte(`{
+				"type":"neki_router",
+				"name":"analytics",
+				"default":false,
+				"sku":{"name":"NKR_10","display_name":"NKR-10","cpu":"2","ram":8589934592,"sort_order":2},
+				"replicas_per_cell":2,
+				"autoscaling":true,
+				"max_replicas_per_cell":4,
+				"target_cpu_utilization":70,
+				"state":"provisioning",
+				"created_at":"2026-08-04T12:00:00Z",
+				"updated_at":"2026-08-05T12:00:00Z"
+			}`))
+
+		case r.Method == http.MethodPost && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/routers":
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			c.Assert(body, qt.DeepEquals, map[string]interface{}{
+				"name":              "analytics",
+				"router_size":       "NKR_10",
+				"replicas_per_cell": float64(2),
+			})
+			w.WriteHeader(http.StatusCreated)
+			_, _ = w.Write([]byte(`{
+				"type":"neki_router",
+				"name":"analytics",
+				"default":false,
+				"sku":{"name":"NKR_10","display_name":"NKR-10","cpu":"2","ram":8589934592,"sort_order":2},
+				"replicas_per_cell":2,
+				"autoscaling":false,
+				"max_replicas_per_cell":null,
+				"target_cpu_utilization":null,
+				"state":"provisioning",
+				"created_at":"2026-08-04T12:00:00Z",
+				"updated_at":"2026-08-04T12:00:00Z"
+			}`))
+
+		case r.Method == http.MethodPatch && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/routers/analytics":
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			c.Assert(body, qt.DeepEquals, map[string]interface{}{
+				"autoscaling":            true,
+				"max_replicas_per_cell":  float64(4),
+				"target_cpu_utilization": float64(70),
+				"parameters": map[string]interface{}{
+					"router": map[string]interface{}{"replication-lag-tolerable-max": "15m"},
+				},
+			})
+			_, _ = w.Write([]byte(`{
+				"type":"neki_router",
+				"name":"analytics",
+				"default":false,
+				"sku":{"name":"NKR_10","display_name":"NKR-10","cpu":"2","ram":8589934592,"sort_order":2},
+				"replicas_per_cell":2,
+				"autoscaling":true,
+				"max_replicas_per_cell":4,
+				"target_cpu_utilization":70,
+				"state":"updating",
+				"created_at":"2026-08-04T12:00:00Z",
+				"updated_at":"2026-08-05T12:00:00Z"
+			}`))
+
+		case r.Method == http.MethodGet && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/router-size-skus":
+			c.Assert(r.URL.Query().Get("rates"), qt.Equals, "true")
+			_, _ = w.Write([]byte(`[{
+				"name":"NKR_5","display_name":"NKR-5","cpu":"1","ram":4294967296,"sort_order":1,"rate":25
+			}]`))
+
+		case r.Method == http.MethodGet && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/routers/analytics/parameters":
+			_, _ = w.Write([]byte(`[{
+				"name":"replication-lag-tolerable-max",
+				"display_name":"Replication lag tolerable max",
+				"namespace":"router",
+				"advanced":false,
+				"category":null,
+				"description":"Maximum tolerated replication lag",
+				"parameter_type":"duration",
+				"default_value":"10m",
+				"value":"15m",
+				"required":false,
+				"created_at":"2026-08-04T12:00:00Z",
+				"updated_at":"2026-08-05T12:00:00Z",
+				"restart":false,
+				"url":"https://planetscale.com/docs"
+			}]`))
+
+		case r.Method == http.MethodGet && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/routers/analytics/changes":
+			c.Assert(r.URL.Query().Get("period"), qt.Equals, "24h")
+			c.Assert(r.URL.Query().Get("completed_at"), qt.Equals, "2026-08-04")
+			c.Assert(r.URL.Query().Get("page"), qt.Equals, "2")
+			c.Assert(r.URL.Query().Get("per_page"), qt.Equals, "25")
+			_, _ = w.Write([]byte(`{"data":[{"id":"change-1","state":"pending","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z","router_size":"NKR_10","previous_router_size":"NKR_5","replicas_per_cell":2,"previous_replicas_per_cell":1,"parameters":{"router":{"replication-lag-tolerable-max":"15m"}},"previous_parameters":{"router":{"replication-lag-tolerable-max":"10m"}}}]}`))
+
+		case r.Method == http.MethodGet && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/routers/analytics/changes/change-1":
+			_, _ = w.Write([]byte(`{"id":"change-1","state":"pending","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z","router_size":"NKR_10","previous_router_size":"NKR_5","replicas_per_cell":2,"previous_replicas_per_cell":1}`))
+
+		case r.Method == http.MethodDelete && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/routers/analytics/changes/change-1":
+			w.WriteHeader(http.StatusNoContent)
+
+		case r.Method == http.MethodDelete && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/routers/analytics":
+			w.WriteHeader(http.StatusNoContent)
+
+		default:
+			http.Error(w, "unexpected request", http.StatusNotFound)
+		}
+	}))
+	defer ts.Close()
+
+	client, err := NewClient(WithBaseURL(ts.URL))
+	c.Assert(err, qt.IsNil)
+	ctx := context.Background()
+
+	routers, err := client.NekiRouters.List(ctx, &ListNekiRoutersRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(routers, qt.HasLen, 1)
+	c.Assert(routers[0].Name, qt.Equals, "default")
+	c.Assert(routers[0].Default, qt.IsTrue)
+	c.Assert(routers[0].State, qt.Equals, "ready")
+	c.Assert(routers[0].SKU.Name, qt.Equals, "NKR_5")
+
+	router, err := client.NekiRouters.Get(ctx, &GetNekiRouterRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Router:       "analytics",
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(router.Name, qt.Equals, "analytics")
+	c.Assert(router.Autoscaling, qt.IsTrue)
+	c.Assert(*router.MaxReplicasPerCell, qt.Equals, 4)
+	c.Assert(*router.TargetCPUUtilization, qt.Equals, 70)
+
+	replicas := 2
+	router, err = client.NekiRouters.Create(ctx, &CreateNekiRouterRequest{
+		Organization:    "acme",
+		Database:        "app",
+		Branch:          "main",
+		Name:            "analytics",
+		RouterSize:      "NKR_10",
+		ReplicasPerCell: &replicas,
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(router.Name, qt.Equals, "analytics")
+	c.Assert(router.State, qt.Equals, "provisioning")
+
+	autoscaling := true
+	maxReplicas := 4
+	targetCPU := 70
+	router, err = client.NekiRouters.Update(ctx, &UpdateNekiRouterRequest{
+		Organization:         "acme",
+		Database:             "app",
+		Branch:               "main",
+		Router:               "analytics",
+		Autoscaling:          &autoscaling,
+		MaxReplicasPerCell:   &maxReplicas,
+		TargetCPUUtilization: &targetCPU,
+		Parameters: map[string]map[string]string{
+			"router": {"replication-lag-tolerable-max": "15m"},
+		},
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(router.State, qt.Equals, "updating")
+	c.Assert(router.Autoscaling, qt.IsTrue)
+
+	skus, err := client.NekiRouters.ListSizeSKUs(ctx, &ListNekiRouterSizeSKUsRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Rates:        true,
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(skus, qt.HasLen, 1)
+	c.Assert(skus[0].Name, qt.Equals, "NKR_5")
+	c.Assert(skus[0].DisplayName, qt.Equals, "NKR-5")
+	c.Assert(*skus[0].Rate, qt.Equals, int64(25))
+
+	parameters, err := client.NekiRouters.ListParameters(ctx, &ListNekiRouterParametersRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Router:       "analytics",
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(parameters, qt.HasLen, 1)
+	c.Assert(parameters[0].Name, qt.Equals, "replication-lag-tolerable-max")
+	c.Assert(parameters[0].Namespace, qt.Equals, "router")
+	c.Assert(parameters[0].Value, qt.Equals, "15m")
+
+	changes, err := client.NekiRouters.ListChanges(ctx, &ListNekiRouterChangesRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Router:       "analytics",
+		Period:       "24h",
+		CompletedAt:  "2026-08-04",
+		Page:         2,
+		PerPage:      25,
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(changes, qt.HasLen, 1)
+	c.Assert(changes[0].ID, qt.Equals, "change-1")
+	c.Assert(changes[0].RouterSize, qt.Equals, "NKR_10")
+	c.Assert(changes[0].PreviousRouterSize, qt.Equals, "NKR_5")
+
+	change, err := client.NekiRouters.GetChange(ctx, &GetNekiRouterChangeRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Router:       "analytics",
+		Change:       "change-1",
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(change.State, qt.Equals, "pending")
+	c.Assert(change.ReplicasPerCell, qt.Equals, 2)
+
+	err = client.NekiRouters.CancelChange(ctx, &CancelNekiRouterChangeRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Router:       "analytics",
+		Change:       "change-1",
+	})
+	c.Assert(err, qt.IsNil)
+
+	err = client.NekiRouters.Delete(ctx, &DeleteNekiRouterRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Router:       "analytics",
+	})
+	c.Assert(err, qt.IsNil)
+}
diff --git a/internal/planetscale/neki_shard_configuration_profiles.go b/internal/planetscale/neki_shard_configuration_profiles.go
new file mode 100644
index 000000000..faa61659d
--- /dev/null
+++ b/internal/planetscale/neki_shard_configuration_profiles.go
@@ -0,0 +1,411 @@
+package planetscale
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"path"
+	"time"
+)
+
+type NekiStorage struct {
+	MinimumStorageBytes   *int64 `json:"minimum_storage_bytes,omitempty"`
+	MaximumStorageBytes   *int64 `json:"maximum_storage_bytes,omitempty"`
+	StorageAutoscaling    *bool  `json:"storage_autoscaling,omitempty"`
+	StorageIOPS           *int64 `json:"storage_iops,omitempty"`
+	StorageThroughputMiBs *int64 `json:"storage_throughput_mibs,omitempty"`
+}
+
+type NekiShardConfigurationProfile struct {
+	Type                 string       `json:"type,omitempty"`
+	Name                 string       `json:"name"`
+	Architecture         string       `json:"architecture"`
+	ClusterSize          string       `json:"cluster_size"`
+	ClusterDisplayName   string       `json:"cluster_display_name"`
+	Default              bool         `json:"default"`
+	Metal                bool         `json:"metal"`
+	Replicas             int          `json:"replicas"`
+	PostgresMajorVersion int          `json:"postgres_major_version"`
+	PostgresMinorVersion int          `json:"postgres_minor_version"`
+	Shards               int          `json:"shards"`
+	State                string       `json:"state"`
+	Storage              *NekiStorage `json:"storage,omitempty"`
+	CreatedAt            time.Time    `json:"created_at"`
+	UpdatedAt            time.Time    `json:"updated_at"`
+}
+
+type ListNekiShardConfigurationProfilesRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+}
+
+type GetNekiShardConfigurationProfileRequest struct {
+	Organization         string `json:"-"`
+	Database             string `json:"-"`
+	Branch               string `json:"-"`
+	ConfigurationProfile string `json:"-"`
+}
+
+type CreateNekiShardConfigurationProfileRequest struct {
+	Organization         string       `json:"-"`
+	Database             string       `json:"-"`
+	Branch               string       `json:"-"`
+	Name                 string       `json:"name"`
+	ClusterSize          *string      `json:"cluster_size,omitempty"`
+	Replicas             *int         `json:"replicas,omitempty"`
+	PostgresMajorVersion *string      `json:"postgres_major_version,omitempty"`
+	PostgresMinorVersion *string      `json:"postgres_minor_version,omitempty"`
+	Storage              *NekiStorage `json:"storage,omitempty"`
+}
+
+type UpdateNekiShardConfigurationProfileRequest struct {
+	Organization         string                       `json:"-"`
+	Database             string                       `json:"-"`
+	Branch               string                       `json:"-"`
+	ConfigurationProfile string                       `json:"-"`
+	Name                 *string                      `json:"name,omitempty"`
+	ClusterSize          *string                      `json:"cluster_size,omitempty"`
+	Replicas             *int                         `json:"replicas,omitempty"`
+	Parameters           map[string]map[string]string `json:"parameters,omitempty"`
+	PostgresMajorVersion *string                      `json:"postgres_major_version,omitempty"`
+	PostgresMinorVersion *string                      `json:"postgres_minor_version,omitempty"`
+	Storage              *NekiStorage                 `json:"storage,omitempty"`
+}
+
+type DeleteNekiShardConfigurationProfileRequest struct {
+	Organization         string `json:"-"`
+	Database             string `json:"-"`
+	Branch               string `json:"-"`
+	ConfigurationProfile string `json:"-"`
+}
+
+type GetDefaultNekiShardConfigurationProfileRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+}
+
+type SetDefaultNekiShardConfigurationProfileRequest struct {
+	Organization         string `json:"-"`
+	Database             string `json:"-"`
+	Branch               string `json:"-"`
+	ConfigurationProfile string `json:"configuration_profile"`
+}
+
+type NekiParameter struct {
+	Type          string      `json:"type,omitempty"`
+	Name          string      `json:"name"`
+	DisplayName   string      `json:"display_name"`
+	Namespace     string      `json:"namespace"`
+	Advanced      bool        `json:"advanced"`
+	Category      *string     `json:"category"`
+	Description   string      `json:"description"`
+	ParameterType string      `json:"parameter_type"`
+	DefaultValue  interface{} `json:"default_value"`
+	Value         interface{} `json:"value"`
+	Required      bool        `json:"required"`
+	CreatedAt     time.Time   `json:"created_at"`
+	UpdatedAt     *time.Time  `json:"updated_at"`
+	Restart       bool        `json:"restart"`
+	// Min, Max, and Step are numbers for plain numeric parameters but strings
+	// for byte- and time-typed ones (for example, "128kB" or "10min").
+	Max     any      `json:"max,omitempty"`
+	Min     any      `json:"min,omitempty"`
+	Step    any      `json:"step,omitempty"`
+	Options []string `json:"options,omitempty"`
+	Units   []string `json:"units,omitempty"`
+	URL     string   `json:"url"`
+	Actor   *Actor   `json:"actor,omitempty"`
+}
+
+type ListNekiShardConfigurationProfileParametersRequest struct {
+	Organization         string `json:"-"`
+	Database             string `json:"-"`
+	Branch               string `json:"-"`
+	ConfigurationProfile string `json:"-"`
+	Extension            *bool  `json:"-"`
+	Internal             *bool  `json:"-"`
+}
+
+type NekiExtension struct {
+	Type        string           `json:"type,omitempty"`
+	Name        string           `json:"name"`
+	Description string           `json:"description"`
+	Enabled     bool             `json:"enabled"`
+	Internal    bool             `json:"internal"`
+	Loader      string           `json:"loader"`
+	URL         string           `json:"url"`
+	Parameters  []*NekiParameter `json:"parameters"`
+}
+
+type ListNekiShardConfigurationProfileExtensionsRequest struct {
+	Organization         string `json:"-"`
+	Database             string `json:"-"`
+	Branch               string `json:"-"`
+	ConfigurationProfile string `json:"-"`
+}
+
+type UpdateNekiShardConfigurationProfileExtensionRequest struct {
+	Organization         string `json:"-"`
+	Database             string `json:"-"`
+	Branch               string `json:"-"`
+	ConfigurationProfile string `json:"-"`
+	Extension            string `json:"-"`
+	Enabled              bool   `json:"enabled"`
+}
+
+type RunNekiShardConfigurationProfileMaintenanceRequest struct {
+	Organization         string `json:"-"`
+	Database             string `json:"-"`
+	Branch               string `json:"-"`
+	ConfigurationProfile string `json:"-"`
+}
+
+type RunNekiShardConfigurationProfilesMaintenanceRequest struct {
+	Organization              string   `json:"-"`
+	Database                  string   `json:"-"`
+	Branch                    string   `json:"-"`
+	ConfigurationProfileNames []string `json:"configuration_profile_names"`
+}
+
+type NekiShardConfigurationProfileChange struct {
+	Type                       string                       `json:"type,omitempty"`
+	ID                         string                       `json:"id"`
+	State                      string                       `json:"state"`
+	StartedAt                  *time.Time                   `json:"started_at"`
+	CompletedAt                *time.Time                   `json:"completed_at"`
+	CreatedAt                  time.Time                    `json:"created_at"`
+	UpdatedAt                  time.Time                    `json:"updated_at"`
+	Name                       string                       `json:"name"`
+	PreviousName               string                       `json:"previous_name"`
+	ClusterSize                string                       `json:"cluster_size"`
+	ClusterDisplayName         string                       `json:"cluster_display_name"`
+	Metal                      bool                         `json:"metal"`
+	ClusterRank                int                          `json:"cluster_rank"`
+	Replicas                   int                          `json:"replicas"`
+	Parameters                 map[string]map[string]string `json:"parameters"`
+	PreviousClusterSize        string                       `json:"previous_cluster_size"`
+	PreviousClusterDisplayName string                       `json:"previous_cluster_display_name"`
+	PreviousMetal              bool                         `json:"previous_metal"`
+	PreviousClusterRank        int                          `json:"previous_cluster_rank"`
+	PreviousReplicas           int                          `json:"previous_replicas"`
+	PreviousParameters         map[string]map[string]string `json:"previous_parameters"`
+	Storage                    *NekiStorage                 `json:"storage,omitempty"`
+	PreviousStorage            *NekiStorage                 `json:"previous_storage,omitempty"`
+	Actor                      *Actor                       `json:"actor,omitempty"`
+}
+
+type ListNekiShardConfigurationProfileChangesRequest struct {
+	Organization         string `json:"-"`
+	Database             string `json:"-"`
+	Branch               string `json:"-"`
+	ConfigurationProfile string `json:"-"`
+	Period               string `json:"-"`
+	CompletedAt          string `json:"-"`
+	Page                 int    `json:"-"`
+	PerPage              int    `json:"-"`
+}
+
+type GetNekiShardConfigurationProfileChangeRequest struct {
+	Organization         string `json:"-"`
+	Database             string `json:"-"`
+	Branch               string `json:"-"`
+	ConfigurationProfile string `json:"-"`
+	Change               string `json:"-"`
+}
+
+type CancelNekiShardConfigurationProfileChangeRequest = GetNekiShardConfigurationProfileChangeRequest
+
+type nekiShardConfigurationProfileChangesResponse struct {
+	Changes []*NekiShardConfigurationProfileChange `json:"data"`
+}
+
+type NekiShardConfigurationProfilesService interface {
+	List(context.Context, *ListNekiShardConfigurationProfilesRequest) ([]*NekiShardConfigurationProfile, error)
+	Get(context.Context, *GetNekiShardConfigurationProfileRequest) (*NekiShardConfigurationProfile, error)
+	Create(context.Context, *CreateNekiShardConfigurationProfileRequest) (*NekiShardConfigurationProfile, error)
+	Update(context.Context, *UpdateNekiShardConfigurationProfileRequest) (*NekiShardConfigurationProfile, error)
+	Delete(context.Context, *DeleteNekiShardConfigurationProfileRequest) error
+	GetDefault(context.Context, *GetDefaultNekiShardConfigurationProfileRequest) (*NekiShardConfigurationProfile, error)
+	SetDefault(context.Context, *SetDefaultNekiShardConfigurationProfileRequest) (*NekiShardConfigurationProfile, error)
+	ListParameters(context.Context, *ListNekiShardConfigurationProfileParametersRequest) ([]*NekiParameter, error)
+	ListExtensions(context.Context, *ListNekiShardConfigurationProfileExtensionsRequest) ([]*NekiExtension, error)
+	UpdateExtension(context.Context, *UpdateNekiShardConfigurationProfileExtensionRequest) (*NekiExtension, error)
+	RunMaintenance(context.Context, *RunNekiShardConfigurationProfileMaintenanceRequest) error
+	RunBulkMaintenance(context.Context, *RunNekiShardConfigurationProfilesMaintenanceRequest) error
+	ListChanges(context.Context, *ListNekiShardConfigurationProfileChangesRequest) ([]*NekiShardConfigurationProfileChange, error)
+	GetChange(context.Context, *GetNekiShardConfigurationProfileChangeRequest) (*NekiShardConfigurationProfileChange, error)
+	CancelChange(context.Context, *CancelNekiShardConfigurationProfileChangeRequest) error
+}
+
+type nekiShardConfigurationProfilesService struct{ client *Client }
+
+var _ NekiShardConfigurationProfilesService = &nekiShardConfigurationProfilesService{}
+
+func (s *nekiShardConfigurationProfilesService) List(ctx context.Context, r *ListNekiShardConfigurationProfilesRequest) ([]*NekiShardConfigurationProfile, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiShardConfigurationProfilesAPIPath(r.Organization, r.Database, r.Branch), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list shard configuration profiles: %w", err)
+	}
+	profiles := []*NekiShardConfigurationProfile{}
+	if err := s.client.do(ctx, request, &profiles); err != nil {
+		return nil, err
+	}
+	return profiles, nil
+}
+
+func (s *nekiShardConfigurationProfilesService) Get(ctx context.Context, r *GetNekiShardConfigurationProfileRequest) (*NekiShardConfigurationProfile, error) {
+	return s.getProfile(ctx, http.MethodGet, nekiShardConfigurationProfileAPIPath(r.Organization, r.Database, r.Branch, r.ConfigurationProfile), nil)
+}
+
+func (s *nekiShardConfigurationProfilesService) Create(ctx context.Context, r *CreateNekiShardConfigurationProfileRequest) (*NekiShardConfigurationProfile, error) {
+	return s.getProfile(ctx, http.MethodPost, nekiShardConfigurationProfilesAPIPath(r.Organization, r.Database, r.Branch), r)
+}
+
+func (s *nekiShardConfigurationProfilesService) Update(ctx context.Context, r *UpdateNekiShardConfigurationProfileRequest) (*NekiShardConfigurationProfile, error) {
+	return s.getProfile(ctx, http.MethodPatch, nekiShardConfigurationProfileAPIPath(r.Organization, r.Database, r.Branch, r.ConfigurationProfile), r)
+}
+
+func (s *nekiShardConfigurationProfilesService) Delete(ctx context.Context, r *DeleteNekiShardConfigurationProfileRequest) error {
+	request, err := s.client.newRequest(http.MethodDelete, nekiShardConfigurationProfileAPIPath(r.Organization, r.Database, r.Branch, r.ConfigurationProfile), nil)
+	if err != nil {
+		return fmt.Errorf("error creating request to delete shard configuration profile: %w", err)
+	}
+	return s.client.do(ctx, request, nil)
+}
+
+func (s *nekiShardConfigurationProfilesService) GetDefault(ctx context.Context, r *GetDefaultNekiShardConfigurationProfileRequest) (*NekiShardConfigurationProfile, error) {
+	return s.getProfile(ctx, http.MethodGet, nekiDefaultShardConfigurationProfileAPIPath(r.Organization, r.Database, r.Branch), nil)
+}
+
+func (s *nekiShardConfigurationProfilesService) SetDefault(ctx context.Context, r *SetDefaultNekiShardConfigurationProfileRequest) (*NekiShardConfigurationProfile, error) {
+	return s.getProfile(ctx, http.MethodPut, nekiDefaultShardConfigurationProfileAPIPath(r.Organization, r.Database, r.Branch), r)
+}
+
+func (s *nekiShardConfigurationProfilesService) ListParameters(ctx context.Context, r *ListNekiShardConfigurationProfileParametersRequest) ([]*NekiParameter, error) {
+	values := defaultListOptions()
+	if r.Extension != nil {
+		values.URLValues.Set("extension", fmt.Sprintf("%t", *r.Extension))
+	}
+	if r.Internal != nil {
+		values.URLValues.Set("internal", fmt.Sprintf("%t", *r.Internal))
+	}
+	request, err := s.client.newRequest(http.MethodGet, path.Join(nekiShardConfigurationProfileAPIPath(r.Organization, r.Database, r.Branch, r.ConfigurationProfile), "parameters"), nil, WithQueryParams(*values.URLValues))
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list shard configuration profile parameters: %w", err)
+	}
+	parameters := []*NekiParameter{}
+	if err := s.client.do(ctx, request, &parameters); err != nil {
+		return nil, err
+	}
+	return parameters, nil
+}
+
+func (s *nekiShardConfigurationProfilesService) ListExtensions(ctx context.Context, r *ListNekiShardConfigurationProfileExtensionsRequest) ([]*NekiExtension, error) {
+	request, err := s.client.newRequest(http.MethodGet, path.Join(nekiShardConfigurationProfileAPIPath(r.Organization, r.Database, r.Branch, r.ConfigurationProfile), "extensions"), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list shard configuration profile extensions: %w", err)
+	}
+	extensions := []*NekiExtension{}
+	if err := s.client.do(ctx, request, &extensions); err != nil {
+		return nil, err
+	}
+	return extensions, nil
+}
+
+func (s *nekiShardConfigurationProfilesService) UpdateExtension(ctx context.Context, r *UpdateNekiShardConfigurationProfileExtensionRequest) (*NekiExtension, error) {
+	request, err := s.client.newRequest(http.MethodPatch, path.Join(nekiShardConfigurationProfileAPIPath(r.Organization, r.Database, r.Branch, r.ConfigurationProfile), "extensions", r.Extension), r)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to update shard configuration profile extension: %w", err)
+	}
+	extension := &NekiExtension{}
+	if err := s.client.do(ctx, request, extension); err != nil {
+		return nil, err
+	}
+	return extension, nil
+}
+
+func (s *nekiShardConfigurationProfilesService) RunMaintenance(ctx context.Context, r *RunNekiShardConfigurationProfileMaintenanceRequest) error {
+	request, err := s.client.newRequest(http.MethodPost, path.Join(nekiShardConfigurationProfileAPIPath(r.Organization, r.Database, r.Branch, r.ConfigurationProfile), "maintenance"), nil)
+	if err != nil {
+		return fmt.Errorf("error creating request to run shard configuration profile maintenance: %w", err)
+	}
+	return s.client.do(ctx, request, nil)
+}
+
+func (s *nekiShardConfigurationProfilesService) RunBulkMaintenance(ctx context.Context, r *RunNekiShardConfigurationProfilesMaintenanceRequest) error {
+	request, err := s.client.newRequest(http.MethodPost, path.Join(nekiShardConfigurationProfilesAPIPath(r.Organization, r.Database, r.Branch), "maintenance"), r)
+	if err != nil {
+		return fmt.Errorf("error creating request to run shard configuration profile maintenance: %w", err)
+	}
+	return s.client.do(ctx, request, nil)
+}
+
+func (s *nekiShardConfigurationProfilesService) ListChanges(ctx context.Context, r *ListNekiShardConfigurationProfileChangesRequest) ([]*NekiShardConfigurationProfileChange, error) {
+	values := defaultListOptions(WithPeriod(r.Period), WithPage(r.Page), WithPerPage(r.PerPage))
+	if r.CompletedAt != "" {
+		values.URLValues.Set("completed_at", r.CompletedAt)
+	}
+	request, err := s.client.newRequest(http.MethodGet, nekiShardConfigurationProfileChangesAPIPath(r.Organization, r.Database, r.Branch, r.ConfigurationProfile), nil, WithQueryParams(*values.URLValues))
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list shard configuration profile changes: %w", err)
+	}
+	response := &nekiShardConfigurationProfileChangesResponse{}
+	if err := s.client.do(ctx, request, response); err != nil {
+		return nil, err
+	}
+	return response.Changes, nil
+}
+
+func (s *nekiShardConfigurationProfilesService) GetChange(ctx context.Context, r *GetNekiShardConfigurationProfileChangeRequest) (*NekiShardConfigurationProfileChange, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiShardConfigurationProfileChangeAPIPath(r.Organization, r.Database, r.Branch, r.ConfigurationProfile, r.Change), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to get shard configuration profile change: %w", err)
+	}
+	change := &NekiShardConfigurationProfileChange{}
+	if err := s.client.do(ctx, request, change); err != nil {
+		return nil, err
+	}
+	return change, nil
+}
+
+func (s *nekiShardConfigurationProfilesService) CancelChange(ctx context.Context, r *CancelNekiShardConfigurationProfileChangeRequest) error {
+	request, err := s.client.newRequest(http.MethodDelete, nekiShardConfigurationProfileChangeAPIPath(r.Organization, r.Database, r.Branch, r.ConfigurationProfile, r.Change), nil)
+	if err != nil {
+		return fmt.Errorf("error creating request to cancel shard configuration profile change: %w", err)
+	}
+	return s.client.do(ctx, request, nil)
+}
+
+func (s *nekiShardConfigurationProfilesService) getProfile(ctx context.Context, method, pathStr string, body interface{}) (*NekiShardConfigurationProfile, error) {
+	request, err := s.client.newRequest(method, pathStr, body)
+	if err != nil {
+		return nil, fmt.Errorf("error creating shard configuration profile request: %w", err)
+	}
+	profile := &NekiShardConfigurationProfile{}
+	if err := s.client.do(ctx, request, profile); err != nil {
+		return nil, err
+	}
+	return profile, nil
+}
+
+func nekiShardConfigurationProfilesAPIPath(org, database, branch string) string {
+	return path.Join(databaseBranchAPIPath(org, database, branch), "configuration-profiles")
+}
+
+func nekiShardConfigurationProfileAPIPath(org, database, branch, profile string) string {
+	return path.Join(nekiShardConfigurationProfilesAPIPath(org, database, branch), profile)
+}
+
+func nekiDefaultShardConfigurationProfileAPIPath(org, database, branch string) string {
+	return path.Join(databaseBranchAPIPath(org, database, branch), "default-configuration-profile")
+}
+
+func nekiShardConfigurationProfileChangesAPIPath(org, database, branch, profile string) string {
+	return path.Join(nekiShardConfigurationProfileAPIPath(org, database, branch, profile), "changes")
+}
+
+func nekiShardConfigurationProfileChangeAPIPath(org, database, branch, profile, change string) string {
+	return path.Join(nekiShardConfigurationProfileChangesAPIPath(org, database, branch, profile), change)
+}
diff --git a/internal/planetscale/neki_shard_configuration_profiles_test.go b/internal/planetscale/neki_shard_configuration_profiles_test.go
new file mode 100644
index 000000000..c8c2d9f20
--- /dev/null
+++ b/internal/planetscale/neki_shard_configuration_profiles_test.go
@@ -0,0 +1,241 @@
+package planetscale
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestNekiShardConfigurationProfilesService(t *testing.T) {
+	c := qt.New(t)
+	const basePath = "/v1/organizations/acme/databases/app/branches/main"
+	const profilesPath = basePath + "/configuration-profiles"
+	const profilePath = profilesPath + "/metal"
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		writeProfile := func() {
+			_, _ = w.Write([]byte(`{"name":"metal","architecture":"arm64","cluster_size":"M1-10","cluster_display_name":"Metal 10","default":true,"metal":true,"replicas":2,"postgres_major_version":17,"postgres_minor_version":6,"shards":3,"state":"ready","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z"}`))
+		}
+
+		switch {
+		case r.Method == http.MethodGet && r.URL.Path == profilesPath:
+			_, _ = w.Write([]byte(`[{"name":"metal","architecture":"arm64","cluster_size":"M1-10","cluster_display_name":"Metal 10","default":true,"metal":true,"replicas":2,"postgres_major_version":17,"postgres_minor_version":6,"shards":3,"state":"ready","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z"}]`))
+
+		case r.Method == http.MethodGet && r.URL.Path == profilePath:
+			writeProfile()
+
+		case r.Method == http.MethodPost && r.URL.Path == profilesPath+"/maintenance":
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			c.Assert(body, qt.DeepEquals, map[string]interface{}{
+				"configuration_profile_names": []interface{}{"metal", "analytics"},
+			})
+			w.WriteHeader(http.StatusNoContent)
+
+		case r.Method == http.MethodPost && r.URL.Path == profilePath+"/maintenance":
+			w.WriteHeader(http.StatusNoContent)
+
+		case r.Method == http.MethodPost && r.URL.Path == profilesPath:
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			if _, ok := body["storage"]; ok {
+				c.Assert(body, qt.DeepEquals, map[string]interface{}{
+					"name": "analytics",
+					"storage": map[string]interface{}{
+						"minimum_storage_bytes":   float64(10737418240),
+						"maximum_storage_bytes":   float64(107374182400),
+						"storage_autoscaling":     true,
+						"storage_iops":            float64(4000),
+						"storage_throughput_mibs": float64(250),
+					},
+				})
+			} else {
+				c.Assert(body, qt.DeepEquals, map[string]interface{}{
+					"name":                   "metal",
+					"cluster_size":           "M1-10",
+					"replicas":               float64(2),
+					"postgres_major_version": "17",
+					"postgres_minor_version": "6",
+				})
+			}
+			w.WriteHeader(http.StatusCreated)
+			writeProfile()
+
+		case r.Method == http.MethodPatch && r.URL.Path == profilePath+"/extensions/pg_stat_statements":
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			c.Assert(body, qt.DeepEquals, map[string]interface{}{"enabled": true})
+			_, _ = w.Write([]byte(`{"name":"pg_stat_statements","description":"Stats","enabled":true,"internal":true,"loader":"shared_preload_libraries","url":"https://example.test/extension","parameters":[]}`))
+
+		case r.Method == http.MethodPatch && r.URL.Path == profilePath:
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			if _, ok := body["storage"]; ok {
+				c.Assert(body, qt.DeepEquals, map[string]interface{}{
+					"storage": map[string]interface{}{
+						"minimum_storage_bytes": float64(21474836480),
+						"storage_autoscaling":   false,
+					},
+				})
+			} else {
+				c.Assert(body, qt.DeepEquals, map[string]interface{}{
+					"name":       "metal-default",
+					"parameters": map[string]interface{}{"pgconf": map[string]interface{}{"max_connections": "200"}},
+				})
+			}
+			writeProfile()
+
+		case r.Method == http.MethodDelete && r.URL.Path == profilePath:
+			w.WriteHeader(http.StatusNoContent)
+
+		case r.Method == http.MethodGet && r.URL.Path == basePath+"/default-configuration-profile":
+			http.Redirect(w, r, profilePath, http.StatusFound)
+
+		case r.Method == http.MethodPut && r.URL.Path == basePath+"/default-configuration-profile":
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			c.Assert(body, qt.DeepEquals, map[string]interface{}{"configuration_profile": "metal"})
+			writeProfile()
+
+		case r.Method == http.MethodGet && r.URL.Path == profilePath+"/parameters":
+			c.Assert(r.URL.Query().Get("extension"), qt.Equals, "false")
+			c.Assert(r.URL.Query().Get("internal"), qt.Equals, "true")
+			_, _ = w.Write([]byte(`[{"name":"shared_buffers","display_name":"Shared buffers","namespace":"pgconf","advanced":false,"category":null,"description":"Shared memory buffers","parameter_type":"bytes","default_value":"128MB","value":"256MB","required":false,"created_at":"2026-08-04T12:00:00Z","updated_at":null,"restart":true,"max":"8589934584kB","min":"128kB","units":["kB","MB","GB"],"url":"https://example.test/parameter"}]`))
+
+		case r.Method == http.MethodGet && r.URL.Path == profilePath+"/extensions":
+			_, _ = w.Write([]byte(`[{"name":"pg_stat_statements","description":"Stats","enabled":true,"internal":true,"loader":"shared_preload_libraries","url":"https://example.test/extension","parameters":[]}]`))
+
+		case r.Method == http.MethodGet && r.URL.Path == profilePath+"/changes":
+			c.Assert(r.URL.Query().Get("period"), qt.Equals, "24h")
+			c.Assert(r.URL.Query().Get("completed_at"), qt.Equals, "2026-08-04")
+			c.Assert(r.URL.Query().Get("page"), qt.Equals, "2")
+			c.Assert(r.URL.Query().Get("per_page"), qt.Equals, "25")
+			_, _ = w.Write([]byte(`{"data":[{"id":"change-1","state":"pending","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z","name":"metal","previous_name":"default","cluster_size":"M1-10","cluster_display_name":"Metal 10","metal":true,"cluster_rank":1,"replicas":2,"parameters":{},"previous_cluster_size":"PS-10","previous_cluster_display_name":"PS 10","previous_metal":false,"previous_cluster_rank":2,"previous_replicas":0,"previous_parameters":{}}]}`))
+
+		case r.Method == http.MethodGet && r.URL.Path == profilePath+"/changes/change-1":
+			_, _ = w.Write([]byte(`{"id":"change-1","state":"pending","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z","name":"metal","cluster_size":"M1-10","replicas":2,"parameters":{},"previous_parameters":{}}`))
+
+		case r.Method == http.MethodDelete && r.URL.Path == profilePath+"/changes/change-1":
+			w.WriteHeader(http.StatusNoContent)
+
+		default:
+			http.Error(w, "unexpected request", http.StatusNotFound)
+		}
+	}))
+	defer ts.Close()
+
+	client, err := NewClient(WithBaseURL(ts.URL))
+	c.Assert(err, qt.IsNil)
+	ctx := context.Background()
+
+	profiles, err := client.NekiShardConfigurationProfiles.List(ctx, &ListNekiShardConfigurationProfilesRequest{Organization: "acme", Database: "app", Branch: "main"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(profiles, qt.HasLen, 1)
+	c.Assert(profiles[0].Name, qt.Equals, "metal")
+
+	profile, err := client.NekiShardConfigurationProfiles.Get(ctx, &GetNekiShardConfigurationProfileRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(profile.PostgresMajorVersion, qt.Equals, 17)
+
+	clusterSize, replicas, major, minor := "M1-10", 2, "17", "6"
+	_, err = client.NekiShardConfigurationProfiles.Create(ctx, &CreateNekiShardConfigurationProfileRequest{Organization: "acme", Database: "app", Branch: "main", Name: "metal", ClusterSize: &clusterSize, Replicas: &replicas, PostgresMajorVersion: &major, PostgresMinorVersion: &minor})
+	c.Assert(err, qt.IsNil)
+
+	name := "metal-default"
+	_, err = client.NekiShardConfigurationProfiles.Create(ctx, &CreateNekiShardConfigurationProfileRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Name:         "analytics",
+		Storage: &NekiStorage{
+			MinimumStorageBytes:   int64Ptr(10737418240),
+			MaximumStorageBytes:   int64Ptr(107374182400),
+			StorageAutoscaling:    boolPtr(true),
+			StorageIOPS:           int64Ptr(4000),
+			StorageThroughputMiBs: int64Ptr(250),
+		},
+	})
+	c.Assert(err, qt.IsNil)
+
+	_, err = client.NekiShardConfigurationProfiles.Update(ctx, &UpdateNekiShardConfigurationProfileRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal", Name: &name, Parameters: map[string]map[string]string{"pgconf": {"max_connections": "200"}}})
+	c.Assert(err, qt.IsNil)
+
+	_, err = client.NekiShardConfigurationProfiles.Update(ctx, &UpdateNekiShardConfigurationProfileRequest{
+		Organization:         "acme",
+		Database:             "app",
+		Branch:               "main",
+		ConfigurationProfile: "metal",
+		Storage: &NekiStorage{
+			MinimumStorageBytes: int64Ptr(21474836480),
+			StorageAutoscaling:  boolPtr(false),
+		},
+	})
+	c.Assert(err, qt.IsNil)
+
+	defaultProfile, err := client.NekiShardConfigurationProfiles.GetDefault(ctx, &GetDefaultNekiShardConfigurationProfileRequest{Organization: "acme", Database: "app", Branch: "main"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(defaultProfile.Default, qt.IsTrue)
+
+	_, err = client.NekiShardConfigurationProfiles.SetDefault(ctx, &SetDefaultNekiShardConfigurationProfileRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal"})
+	c.Assert(err, qt.IsNil)
+
+	extensionFilter, internal := false, true
+	parameters, err := client.NekiShardConfigurationProfiles.ListParameters(ctx, &ListNekiShardConfigurationProfileParametersRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal", Extension: &extensionFilter, Internal: &internal})
+	c.Assert(err, qt.IsNil)
+	c.Assert(parameters[0].Restart, qt.IsTrue)
+	c.Assert(parameters[0].Max, qt.Equals, "8589934584kB")
+	c.Assert(parameters[0].Min, qt.Equals, "128kB")
+	c.Assert(parameters[0].Units, qt.DeepEquals, []string{"kB", "MB", "GB"})
+
+	extensions, err := client.NekiShardConfigurationProfiles.ListExtensions(ctx, &ListNekiShardConfigurationProfileExtensionsRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(extensions[0].Name, qt.Equals, "pg_stat_statements")
+
+	extension, err := client.NekiShardConfigurationProfiles.UpdateExtension(ctx, &UpdateNekiShardConfigurationProfileExtensionRequest{
+		Organization:         "acme",
+		Database:             "app",
+		Branch:               "main",
+		ConfigurationProfile: "metal",
+		Extension:            "pg_stat_statements",
+		Enabled:              true,
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(extension.Enabled, qt.IsTrue)
+
+	err = client.NekiShardConfigurationProfiles.RunMaintenance(ctx, &RunNekiShardConfigurationProfileMaintenanceRequest{
+		Organization:         "acme",
+		Database:             "app",
+		Branch:               "main",
+		ConfigurationProfile: "metal",
+	})
+	c.Assert(err, qt.IsNil)
+
+	err = client.NekiShardConfigurationProfiles.RunBulkMaintenance(ctx, &RunNekiShardConfigurationProfilesMaintenanceRequest{
+		Organization:              "acme",
+		Database:                  "app",
+		Branch:                    "main",
+		ConfigurationProfileNames: []string{"metal", "analytics"},
+	})
+	c.Assert(err, qt.IsNil)
+
+	changes, err := client.NekiShardConfigurationProfiles.ListChanges(ctx, &ListNekiShardConfigurationProfileChangesRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal", Period: "24h", CompletedAt: "2026-08-04", Page: 2, PerPage: 25})
+	c.Assert(err, qt.IsNil)
+	c.Assert(changes, qt.HasLen, 1)
+	c.Assert(changes[0].ID, qt.Equals, "change-1")
+
+	change, err := client.NekiShardConfigurationProfiles.GetChange(ctx, &GetNekiShardConfigurationProfileChangeRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal", Change: "change-1"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(change.State, qt.Equals, "pending")
+
+	err = client.NekiShardConfigurationProfiles.CancelChange(ctx, &CancelNekiShardConfigurationProfileChangeRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal", Change: "change-1"})
+	c.Assert(err, qt.IsNil)
+
+	err = client.NekiShardConfigurationProfiles.Delete(ctx, &DeleteNekiShardConfigurationProfileRequest{Organization: "acme", Database: "app", Branch: "main", ConfigurationProfile: "metal"})
+	c.Assert(err, qt.IsNil)
+}
+
+func int64Ptr(v int64) *int64 { return &v }
diff --git a/internal/planetscale/neki_shards.go b/internal/planetscale/neki_shards.go
new file mode 100644
index 000000000..82b9808b0
--- /dev/null
+++ b/internal/planetscale/neki_shards.go
@@ -0,0 +1,214 @@
+package planetscale
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"path"
+	"time"
+)
+
+// NekiShard represents a shard managed by a Neki branch.
+type NekiShard struct {
+	ID                   string    `json:"id"`
+	Name                 string    `json:"name"`
+	DisplayName          *string   `json:"display_name"`
+	ConfigurationProfile string    `json:"configuration_profile"`
+	Ready                bool      `json:"ready"`
+	Authoritative        bool      `json:"authoritative"`
+	CreatedAt            time.Time `json:"created_at"`
+}
+
+type nekiShardsResponse struct {
+	Shards []*NekiShard `json:"data"`
+}
+
+// NekiShardAssignment is the result of assigning one shard to a configuration profile.
+type NekiShardAssignment struct {
+	ID     string                 `json:"id"`
+	Status string                 `json:"status"`
+	Error  map[string]interface{} `json:"error,omitempty"`
+}
+
+type ListNekiShardsRequest struct {
+	Organization                string `json:"-"`
+	Database                    string `json:"-"`
+	Branch                      string `json:"-"`
+	ConfigurationProfile        string `json:"-"`
+	ExcludeConfigurationProfile string `json:"-"`
+	Query                       string `json:"-"`
+	Page                        int    `json:"-"`
+	PerPage                     int    `json:"-"`
+}
+
+type CreateNekiShardsRequest struct {
+	Organization         string `json:"-"`
+	Database             string `json:"-"`
+	Branch               string `json:"-"`
+	ConfigurationProfile string `json:"-"`
+	Count                int    `json:"count"`
+}
+
+type CreateNekiShardsResponse struct {
+	Created  int      `json:"created"`
+	ShardIDs []string `json:"shard_ids"`
+}
+
+type AssignNekiShardsRequest struct {
+	Organization         string   `json:"-"`
+	Database             string   `json:"-"`
+	Branch               string   `json:"-"`
+	ConfigurationProfile string   `json:"-"`
+	ShardIDs             []string `json:"shard_ids"`
+}
+
+type UpdateNekiShardRequest struct {
+	Organization string  `json:"-"`
+	Database     string  `json:"-"`
+	Branch       string  `json:"-"`
+	Shard        string  `json:"-"`
+	DisplayName  *string `json:"display_name"`
+}
+
+type GetNekiShardRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Shard        string `json:"-"`
+}
+
+type DeleteNekiShardRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Shard        string `json:"-"`
+}
+
+// NekiShardsService manages shards belonging to Neki branches.
+type NekiShardsService interface {
+	List(context.Context, *ListNekiShardsRequest) ([]*NekiShard, error)
+	Get(context.Context, *GetNekiShardRequest) (*NekiShard, error)
+	Create(context.Context, *CreateNekiShardsRequest) (*CreateNekiShardsResponse, error)
+	Assign(context.Context, *AssignNekiShardsRequest) ([]*NekiShardAssignment, error)
+	Update(context.Context, *UpdateNekiShardRequest) (*NekiShard, error)
+	Delete(context.Context, *DeleteNekiShardRequest) error
+}
+
+type nekiShardsService struct {
+	client *Client
+}
+
+var _ NekiShardsService = &nekiShardsService{}
+
+func NewNekiShardsService(client *Client) *nekiShardsService {
+	return &nekiShardsService{client: client}
+}
+
+func (s *nekiShardsService) List(ctx context.Context, listReq *ListNekiShardsRequest) ([]*NekiShard, error) {
+	pathStr := nekiShardsAPIPath(listReq.Organization, listReq.Database, listReq.Branch)
+	if listReq.ConfigurationProfile != "" {
+		pathStr = nekiShardConfigurationProfileShardsAPIPath(listReq.Organization, listReq.Database, listReq.Branch, listReq.ConfigurationProfile)
+	}
+
+	query := defaultListOptions(
+		WithSearch(listReq.Query),
+		WithPage(listReq.Page),
+		WithPerPage(listReq.PerPage),
+	)
+	if listReq.ExcludeConfigurationProfile != "" {
+		query.URLValues.Set("exclude_configuration_profile", listReq.ExcludeConfigurationProfile)
+	}
+
+	req, err := s.client.newRequest(http.MethodGet, pathStr, nil, WithQueryParams(*query.URLValues))
+	if err != nil {
+		return nil, fmt.Errorf("error creating http request to list shards: %w", err)
+	}
+
+	response := &nekiShardsResponse{}
+	if err := s.client.do(ctx, req, response); err != nil {
+		return nil, err
+	}
+
+	return response.Shards, nil
+}
+
+func (s *nekiShardsService) Get(ctx context.Context, getReq *GetNekiShardRequest) (*NekiShard, error) {
+	req, err := s.client.newRequest(http.MethodGet, nekiShardAPIPath(getReq.Organization, getReq.Database, getReq.Branch, getReq.Shard), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating http request to get shard: %w", err)
+	}
+
+	shard := &NekiShard{}
+	if err := s.client.do(ctx, req, shard); err != nil {
+		return nil, err
+	}
+
+	return shard, nil
+}
+
+func (s *nekiShardsService) Create(ctx context.Context, createReq *CreateNekiShardsRequest) (*CreateNekiShardsResponse, error) {
+	pathStr := path.Join(nekiShardConfigurationProfileShardsAPIPath(createReq.Organization, createReq.Database, createReq.Branch, createReq.ConfigurationProfile), "bulk")
+	req, err := s.client.newRequest(http.MethodPost, pathStr, createReq)
+	if err != nil {
+		return nil, fmt.Errorf("error creating http request to create shards: %w", err)
+	}
+
+	response := &CreateNekiShardsResponse{}
+	if err := s.client.do(ctx, req, response); err != nil {
+		return nil, err
+	}
+
+	return response, nil
+}
+
+func (s *nekiShardsService) Assign(ctx context.Context, assignReq *AssignNekiShardsRequest) ([]*NekiShardAssignment, error) {
+	pathStr := nekiShardConfigurationProfileShardsAPIPath(assignReq.Organization, assignReq.Database, assignReq.Branch, assignReq.ConfigurationProfile)
+	req, err := s.client.newRequest(http.MethodPatch, pathStr, assignReq)
+	if err != nil {
+		return nil, fmt.Errorf("error creating http request to assign shards: %w", err)
+	}
+
+	assignments := []*NekiShardAssignment{}
+	if err := s.client.do(ctx, req, &assignments); err != nil {
+		return nil, err
+	}
+
+	return assignments, nil
+}
+
+func (s *nekiShardsService) Update(ctx context.Context, updateReq *UpdateNekiShardRequest) (*NekiShard, error) {
+	pathStr := nekiShardAPIPath(updateReq.Organization, updateReq.Database, updateReq.Branch, updateReq.Shard)
+	req, err := s.client.newRequest(http.MethodPatch, pathStr, updateReq)
+	if err != nil {
+		return nil, fmt.Errorf("error creating http request to update shard: %w", err)
+	}
+
+	shard := &NekiShard{}
+	if err := s.client.do(ctx, req, shard); err != nil {
+		return nil, err
+	}
+
+	return shard, nil
+}
+
+func (s *nekiShardsService) Delete(ctx context.Context, deleteReq *DeleteNekiShardRequest) error {
+	pathStr := nekiShardAPIPath(deleteReq.Organization, deleteReq.Database, deleteReq.Branch, deleteReq.Shard)
+	req, err := s.client.newRequest(http.MethodDelete, pathStr, nil)
+	if err != nil {
+		return fmt.Errorf("error creating http request to delete shard: %w", err)
+	}
+
+	return s.client.do(ctx, req, nil)
+}
+
+func nekiShardsAPIPath(org, database, branch string) string {
+	return path.Join(databaseBranchAPIPath(org, database, branch), "shards")
+}
+
+func nekiShardAPIPath(org, database, branch, shard string) string {
+	return path.Join(nekiShardsAPIPath(org, database, branch), shard)
+}
+
+func nekiShardConfigurationProfileShardsAPIPath(org, database, branch, configurationProfile string) string {
+	return path.Join(databaseBranchAPIPath(org, database, branch), "configuration-profiles", configurationProfile, "shards")
+}
diff --git a/internal/planetscale/neki_shards_test.go b/internal/planetscale/neki_shards_test.go
new file mode 100644
index 000000000..80e0bea0d
--- /dev/null
+++ b/internal/planetscale/neki_shards_test.go
@@ -0,0 +1,138 @@
+package planetscale
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestNekiShardsService(t *testing.T) {
+	c := qt.New(t)
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.Method == http.MethodGet && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/shards":
+			c.Assert(r.URL.Query().Get("q"), qt.Equals, "report")
+			c.Assert(r.URL.Query().Get("exclude_configuration_profile"), qt.Equals, "archive")
+			c.Assert(r.URL.Query().Get("page"), qt.Equals, "2")
+			c.Assert(r.URL.Query().Get("per_page"), qt.Equals, "25")
+			_, _ = w.Write([]byte(`{"data":[{"id":"shard-1","name":"0","display_name":"reports","configuration_profile":"default","ready":true,"authoritative":true,"created_at":"2026-08-04T12:00:00Z"}]}`))
+
+		case r.Method == http.MethodGet && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/shards/shard-1":
+			_, _ = w.Write([]byte(`{"id":"shard-1","name":"0","display_name":"reports","configuration_profile":"default","ready":true,"authoritative":true,"created_at":"2026-08-04T12:00:00Z"}`))
+
+		case r.Method == http.MethodGet && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/configuration-profiles/analytics/shards":
+			_, _ = w.Write([]byte(`{"data":[{"id":"shard-2","name":"1","display_name":null,"configuration_profile":"analytics","ready":false,"authoritative":false,"created_at":"2026-08-04T12:00:00Z"}]}`))
+
+		case r.Method == http.MethodPost && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/configuration-profiles/analytics/shards/bulk":
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			c.Assert(body, qt.DeepEquals, map[string]interface{}{"count": float64(2)})
+			w.WriteHeader(http.StatusCreated)
+			_, _ = w.Write([]byte(`{"created":2,"shard_ids":["shard-2","shard-3"]}`))
+
+		case r.Method == http.MethodPatch && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/configuration-profiles/analytics/shards":
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			c.Assert(body, qt.DeepEquals, map[string]interface{}{"shard_ids": []interface{}{"shard-1", "shard-2"}})
+			_, _ = w.Write([]byte(`[{"id":"shard-1","status":"assigned"},{"id":"shard-2","status":"failed","error":{"code":"incompatible_architecture"}}]`))
+
+		case r.Method == http.MethodPatch && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/shards/shard-1":
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			c.Assert(body, qt.DeepEquals, map[string]interface{}{"display_name": nil})
+			_, _ = w.Write([]byte(`{"id":"shard-1","name":"0","display_name":null,"configuration_profile":"default","ready":true,"created_at":"2026-08-04T12:00:00Z"}`))
+
+		case r.Method == http.MethodDelete && r.URL.Path == "/v1/organizations/acme/databases/app/branches/main/shards/shard-1":
+			w.WriteHeader(http.StatusNoContent)
+
+		default:
+			http.Error(w, "unexpected request", http.StatusNotFound)
+		}
+	}))
+	defer ts.Close()
+
+	client, err := NewClient(WithBaseURL(ts.URL))
+	c.Assert(err, qt.IsNil)
+	ctx := context.Background()
+
+	shards, err := client.NekiShards.List(ctx, &ListNekiShardsRequest{
+		Organization:                "acme",
+		Database:                    "app",
+		Branch:                      "main",
+		ExcludeConfigurationProfile: "archive",
+		Query:                       "report",
+		Page:                        2,
+		PerPage:                     25,
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(shards, qt.HasLen, 1)
+	c.Assert(shards[0].ID, qt.Equals, "shard-1")
+	c.Assert(shards[0].Ready, qt.IsTrue)
+	c.Assert(shards[0].Authoritative, qt.IsTrue)
+
+	shard, err := client.NekiShards.Get(ctx, &GetNekiShardRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Shard:        "shard-1",
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(shard.ID, qt.Equals, "shard-1")
+	c.Assert(shard.Authoritative, qt.IsTrue)
+
+	shards, err = client.NekiShards.List(ctx, &ListNekiShardsRequest{
+		Organization:         "acme",
+		Database:             "app",
+		Branch:               "main",
+		ConfigurationProfile: "analytics",
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(shards[0].ConfigurationProfile, qt.Equals, "analytics")
+	c.Assert(shards[0].Ready, qt.IsFalse)
+	c.Assert(shards[0].Authoritative, qt.IsFalse)
+
+	created, err := client.NekiShards.Create(ctx, &CreateNekiShardsRequest{
+		Organization:         "acme",
+		Database:             "app",
+		Branch:               "main",
+		ConfigurationProfile: "analytics",
+		Count:                2,
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(created.ShardIDs, qt.DeepEquals, []string{"shard-2", "shard-3"})
+
+	assignments, err := client.NekiShards.Assign(ctx, &AssignNekiShardsRequest{
+		Organization:         "acme",
+		Database:             "app",
+		Branch:               "main",
+		ConfigurationProfile: "analytics",
+		ShardIDs:             []string{"shard-1", "shard-2"},
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(assignments, qt.HasLen, 2)
+	c.Assert(assignments[1].Error["code"], qt.Equals, "incompatible_architecture")
+
+	updated, err := client.NekiShards.Update(ctx, &UpdateNekiShardRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Shard:        "shard-1",
+		DisplayName:  nil,
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(updated.DisplayName, qt.IsNil)
+	c.Assert(updated.Ready, qt.IsTrue)
+
+	err = client.NekiShards.Delete(ctx, &DeleteNekiShardRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Shard:        "shard-1",
+	})
+	c.Assert(err, qt.IsNil)
+}
diff --git a/internal/planetscale/neki_sidecars.go b/internal/planetscale/neki_sidecars.go
new file mode 100644
index 000000000..ff30c2c4d
--- /dev/null
+++ b/internal/planetscale/neki_sidecars.go
@@ -0,0 +1,202 @@
+package planetscale
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"path"
+	"time"
+)
+
+// NekiSidecar represents the connection-pool sidecar for one Neki configuration profile.
+type NekiSidecar struct {
+	Type                 string    `json:"type,omitempty"`
+	ID                   string    `json:"id"`
+	ConfigurationProfile string    `json:"configuration_profile"`
+	State                string    `json:"state"`
+	CreatedAt            time.Time `json:"created_at"`
+	UpdatedAt            time.Time `json:"updated_at"`
+}
+
+type ListNekiSidecarsRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+}
+
+type GetNekiSidecarRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Sidecar      string `json:"-"`
+}
+
+type UpdateNekiSidecarRequest struct {
+	Organization string                       `json:"-"`
+	Database     string                       `json:"-"`
+	Branch       string                       `json:"-"`
+	Sidecar      string                       `json:"-"`
+	Parameters   map[string]map[string]string `json:"parameters,omitempty"`
+}
+
+type ListNekiSidecarParametersRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Sidecar      string `json:"-"`
+}
+
+type NekiSidecarChange struct {
+	Type               string                       `json:"type,omitempty"`
+	ID                 string                       `json:"id"`
+	State              string                       `json:"state"`
+	StartedAt          *time.Time                   `json:"started_at"`
+	CompletedAt        *time.Time                   `json:"completed_at"`
+	CreatedAt          time.Time                    `json:"created_at"`
+	UpdatedAt          time.Time                    `json:"updated_at"`
+	Parameters         map[string]map[string]string `json:"parameters"`
+	PreviousParameters map[string]map[string]string `json:"previous_parameters"`
+	Actor              *Actor                       `json:"actor,omitempty"`
+}
+
+type ListNekiSidecarChangesRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Sidecar      string `json:"-"`
+	Period       string `json:"-"`
+	CompletedAt  string `json:"-"`
+	Page         int    `json:"-"`
+	PerPage      int    `json:"-"`
+}
+
+type GetNekiSidecarChangeRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"-"`
+	Sidecar      string `json:"-"`
+	Change       string `json:"-"`
+}
+
+type CancelNekiSidecarChangeRequest = GetNekiSidecarChangeRequest
+
+type nekiSidecarChangesResponse struct {
+	Changes []*NekiSidecarChange `json:"data"`
+}
+
+// NekiSidecarsService manages sidecars belonging to Neki branches.
+// Sidecars are created and deleted with their configuration profile; this
+// service exposes list, get, and update only.
+type NekiSidecarsService interface {
+	List(context.Context, *ListNekiSidecarsRequest) ([]*NekiSidecar, error)
+	Get(context.Context, *GetNekiSidecarRequest) (*NekiSidecar, error)
+	Update(context.Context, *UpdateNekiSidecarRequest) (*NekiSidecar, error)
+	ListParameters(context.Context, *ListNekiSidecarParametersRequest) ([]*NekiParameter, error)
+	ListChanges(context.Context, *ListNekiSidecarChangesRequest) ([]*NekiSidecarChange, error)
+	GetChange(context.Context, *GetNekiSidecarChangeRequest) (*NekiSidecarChange, error)
+	CancelChange(context.Context, *CancelNekiSidecarChangeRequest) error
+}
+
+type nekiSidecarsService struct{ client *Client }
+
+var _ NekiSidecarsService = &nekiSidecarsService{}
+
+func (s *nekiSidecarsService) List(ctx context.Context, r *ListNekiSidecarsRequest) ([]*NekiSidecar, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiSidecarsAPIPath(r.Organization, r.Database, r.Branch), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list sidecars: %w", err)
+	}
+	sidecars := []*NekiSidecar{}
+	if err := s.client.do(ctx, request, &sidecars); err != nil {
+		return nil, err
+	}
+	return sidecars, nil
+}
+
+func (s *nekiSidecarsService) Get(ctx context.Context, r *GetNekiSidecarRequest) (*NekiSidecar, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiSidecarAPIPath(r.Organization, r.Database, r.Branch, r.Sidecar), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to get sidecar: %w", err)
+	}
+	sidecar := &NekiSidecar{}
+	if err := s.client.do(ctx, request, sidecar); err != nil {
+		return nil, err
+	}
+	return sidecar, nil
+}
+
+func (s *nekiSidecarsService) Update(ctx context.Context, r *UpdateNekiSidecarRequest) (*NekiSidecar, error) {
+	request, err := s.client.newRequest(http.MethodPatch, nekiSidecarAPIPath(r.Organization, r.Database, r.Branch, r.Sidecar), r)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to update sidecar: %w", err)
+	}
+	sidecar := &NekiSidecar{}
+	if err := s.client.do(ctx, request, sidecar); err != nil {
+		return nil, err
+	}
+	return sidecar, nil
+}
+
+func (s *nekiSidecarsService) ListParameters(ctx context.Context, r *ListNekiSidecarParametersRequest) ([]*NekiParameter, error) {
+	request, err := s.client.newRequest(http.MethodGet, path.Join(nekiSidecarAPIPath(r.Organization, r.Database, r.Branch, r.Sidecar), "parameters"), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list sidecar parameters: %w", err)
+	}
+	parameters := []*NekiParameter{}
+	if err := s.client.do(ctx, request, &parameters); err != nil {
+		return nil, err
+	}
+	return parameters, nil
+}
+
+func (s *nekiSidecarsService) ListChanges(ctx context.Context, r *ListNekiSidecarChangesRequest) ([]*NekiSidecarChange, error) {
+	values := defaultListOptions(WithPeriod(r.Period), WithPage(r.Page), WithPerPage(r.PerPage))
+	if r.CompletedAt != "" {
+		values.URLValues.Set("completed_at", r.CompletedAt)
+	}
+	request, err := s.client.newRequest(http.MethodGet, nekiSidecarChangesAPIPath(r.Organization, r.Database, r.Branch, r.Sidecar), nil, WithQueryParams(*values.URLValues))
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to list sidecar changes: %w", err)
+	}
+	response := &nekiSidecarChangesResponse{}
+	if err := s.client.do(ctx, request, response); err != nil {
+		return nil, err
+	}
+	return response.Changes, nil
+}
+
+func (s *nekiSidecarsService) GetChange(ctx context.Context, r *GetNekiSidecarChangeRequest) (*NekiSidecarChange, error) {
+	request, err := s.client.newRequest(http.MethodGet, nekiSidecarChangeAPIPath(r.Organization, r.Database, r.Branch, r.Sidecar, r.Change), nil)
+	if err != nil {
+		return nil, fmt.Errorf("error creating request to get sidecar change: %w", err)
+	}
+	change := &NekiSidecarChange{}
+	if err := s.client.do(ctx, request, change); err != nil {
+		return nil, err
+	}
+	return change, nil
+}
+
+func (s *nekiSidecarsService) CancelChange(ctx context.Context, r *CancelNekiSidecarChangeRequest) error {
+	request, err := s.client.newRequest(http.MethodDelete, nekiSidecarChangeAPIPath(r.Organization, r.Database, r.Branch, r.Sidecar, r.Change), nil)
+	if err != nil {
+		return fmt.Errorf("error creating request to cancel sidecar change: %w", err)
+	}
+	return s.client.do(ctx, request, nil)
+}
+
+func nekiSidecarsAPIPath(org, database, branch string) string {
+	return path.Join(databaseBranchAPIPath(org, database, branch), "sidecars")
+}
+
+func nekiSidecarAPIPath(org, database, branch, sidecar string) string {
+	return path.Join(nekiSidecarsAPIPath(org, database, branch), sidecar)
+}
+
+func nekiSidecarChangesAPIPath(org, database, branch, sidecar string) string {
+	return path.Join(nekiSidecarAPIPath(org, database, branch, sidecar), "changes")
+}
+
+func nekiSidecarChangeAPIPath(org, database, branch, sidecar, change string) string {
+	return path.Join(nekiSidecarChangesAPIPath(org, database, branch, sidecar), change)
+}
diff --git a/internal/planetscale/neki_sidecars_test.go b/internal/planetscale/neki_sidecars_test.go
new file mode 100644
index 000000000..54835d878
--- /dev/null
+++ b/internal/planetscale/neki_sidecars_test.go
@@ -0,0 +1,111 @@
+package planetscale
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestNekiSidecarsService(t *testing.T) {
+	c := qt.New(t)
+	const basePath = "/v1/organizations/acme/databases/app/branches/main"
+	const sidecarsPath = basePath + "/sidecars"
+	const sidecarPath = sidecarsPath + "/metal"
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		writeSidecar := func() {
+			_, _ = w.Write([]byte(`{"type":"neki_sidecar","id":"sidecar-1","configuration_profile":"metal","state":"ready","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z"}`))
+		}
+
+		switch {
+		case r.Method == http.MethodGet && r.URL.Path == sidecarsPath:
+			_, _ = w.Write([]byte(`[{"type":"neki_sidecar","id":"sidecar-1","configuration_profile":"metal","state":"ready","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z"}]`))
+
+		case r.Method == http.MethodGet && r.URL.Path == sidecarPath:
+			writeSidecar()
+
+		case r.Method == http.MethodPatch && r.URL.Path == sidecarPath:
+			var body map[string]interface{}
+			c.Assert(json.NewDecoder(r.Body).Decode(&body), qt.IsNil)
+			c.Assert(body, qt.DeepEquals, map[string]interface{}{
+				"parameters": map[string]interface{}{"pgbouncer": map[string]interface{}{"default_pool_size": "20"}},
+			})
+			_, _ = w.Write([]byte(`{"type":"neki_sidecar","id":"sidecar-1","configuration_profile":"metal","state":"updating","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-05T12:00:00Z"}`))
+
+		case r.Method == http.MethodGet && r.URL.Path == sidecarPath+"/parameters":
+			_, _ = w.Write([]byte(`[{"name":"default_pool_size","display_name":"Default pool size","namespace":"pgbouncer","advanced":false,"category":null,"description":"Default pool size","parameter_type":"integer","default_value":"10","value":"20","required":false,"created_at":"2026-08-04T12:00:00Z","updated_at":null,"restart":false,"url":"https://example.test/parameter"}]`))
+
+		case r.Method == http.MethodGet && r.URL.Path == sidecarPath+"/changes":
+			c.Assert(r.URL.Query().Get("period"), qt.Equals, "24h")
+			c.Assert(r.URL.Query().Get("completed_at"), qt.Equals, "2026-08-04")
+			c.Assert(r.URL.Query().Get("page"), qt.Equals, "2")
+			c.Assert(r.URL.Query().Get("per_page"), qt.Equals, "25")
+			_, _ = w.Write([]byte(`{"data":[{"id":"change-1","state":"pending","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z","parameters":{"pgbouncer":{"default_pool_size":"20"}},"previous_parameters":{"pgbouncer":{"default_pool_size":"10"}}}]}`))
+
+		case r.Method == http.MethodGet && r.URL.Path == sidecarPath+"/changes/change-1":
+			_, _ = w.Write([]byte(`{"id":"change-1","state":"pending","created_at":"2026-08-04T12:00:00Z","updated_at":"2026-08-04T12:00:00Z","parameters":{"pgbouncer":{"default_pool_size":"20"}},"previous_parameters":{"pgbouncer":{"default_pool_size":"10"}}}`))
+
+		case r.Method == http.MethodDelete && r.URL.Path == sidecarPath+"/changes/change-1":
+			w.WriteHeader(http.StatusNoContent)
+
+		case r.Method == http.MethodPost && r.URL.Path == sidecarsPath:
+			http.Error(w, "sidecars cannot be created", http.StatusMethodNotAllowed)
+
+		case r.Method == http.MethodDelete && r.URL.Path == sidecarPath:
+			http.Error(w, "sidecars cannot be deleted", http.StatusMethodNotAllowed)
+
+		default:
+			http.Error(w, "unexpected request", http.StatusNotFound)
+		}
+	}))
+	defer ts.Close()
+
+	client, err := NewClient(WithBaseURL(ts.URL))
+	c.Assert(err, qt.IsNil)
+	ctx := context.Background()
+
+	sidecars, err := client.NekiSidecars.List(ctx, &ListNekiSidecarsRequest{Organization: "acme", Database: "app", Branch: "main"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(sidecars, qt.HasLen, 1)
+	c.Assert(sidecars[0].ID, qt.Equals, "sidecar-1")
+	c.Assert(sidecars[0].ConfigurationProfile, qt.Equals, "metal")
+	c.Assert(sidecars[0].State, qt.Equals, "ready")
+
+	sidecar, err := client.NekiSidecars.Get(ctx, &GetNekiSidecarRequest{Organization: "acme", Database: "app", Branch: "main", Sidecar: "metal"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(sidecar.ID, qt.Equals, "sidecar-1")
+	c.Assert(sidecar.ConfigurationProfile, qt.Equals, "metal")
+
+	sidecar, err = client.NekiSidecars.Update(ctx, &UpdateNekiSidecarRequest{
+		Organization: "acme",
+		Database:     "app",
+		Branch:       "main",
+		Sidecar:      "metal",
+		Parameters:   map[string]map[string]string{"pgbouncer": {"default_pool_size": "20"}},
+	})
+	c.Assert(err, qt.IsNil)
+	c.Assert(sidecar.State, qt.Equals, "updating")
+
+	parameters, err := client.NekiSidecars.ListParameters(ctx, &ListNekiSidecarParametersRequest{Organization: "acme", Database: "app", Branch: "main", Sidecar: "metal"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(parameters, qt.HasLen, 1)
+	c.Assert(parameters[0].Name, qt.Equals, "default_pool_size")
+	c.Assert(parameters[0].Namespace, qt.Equals, "pgbouncer")
+	c.Assert(parameters[0].Value, qt.Equals, "20")
+
+	changes, err := client.NekiSidecars.ListChanges(ctx, &ListNekiSidecarChangesRequest{Organization: "acme", Database: "app", Branch: "main", Sidecar: "metal", Period: "24h", CompletedAt: "2026-08-04", Page: 2, PerPage: 25})
+	c.Assert(err, qt.IsNil)
+	c.Assert(changes, qt.HasLen, 1)
+	c.Assert(changes[0].ID, qt.Equals, "change-1")
+
+	change, err := client.NekiSidecars.GetChange(ctx, &GetNekiSidecarChangeRequest{Organization: "acme", Database: "app", Branch: "main", Sidecar: "metal", Change: "change-1"})
+	c.Assert(err, qt.IsNil)
+	c.Assert(change.State, qt.Equals, "pending")
+
+	err = client.NekiSidecars.CancelChange(ctx, &CancelNekiSidecarChangeRequest{Organization: "acme", Database: "app", Branch: "main", Sidecar: "metal", Change: "change-1"})
+	c.Assert(err, qt.IsNil)
+}
diff --git a/internal/planetscale/postgres_branches.go b/internal/planetscale/postgres_branches.go
index 6fb4f16c9..d2580c1bc 100644
--- a/internal/planetscale/postgres_branches.go
+++ b/internal/planetscale/postgres_branches.go
@@ -33,6 +33,22 @@ type postgresBranchesResponse struct {
 	Branches []*PostgresBranch `json:"data"`
 }
 
+// ConfigurationProfileSize sizes one Neki configuration profile during a backup restore.
+// Omitted profiles inherit the source size and replica count.
+type ConfigurationProfileSize struct {
+	Name        string `json:"name"`
+	ClusterSize string `json:"cluster_size,omitempty"`
+	Replicas    *int   `json:"replicas,omitempty"`
+}
+
+// RouterSize sizes one Neki router during a backup restore.
+// Omitted routers inherit the source size and replica count.
+type RouterSize struct {
+	Name            string `json:"name"`
+	RouterSize      string `json:"router_size,omitempty"`
+	ReplicasPerCell *int   `json:"replicas_per_cell,omitempty"`
+}
+
 // CreatePostgresBranchRequest encapsulates the request to create a Postgres branch.
 type CreatePostgresBranchRequest struct {
 	Organization string         `json:"-"`
@@ -46,6 +62,10 @@ type CreatePostgresBranchRequest struct {
 	MajorVersion string         `json:"major_version,omitempty"`
 	Replicas     *int           `json:"replicas,omitempty"`
 	Storage      *StorageConfig `json:"storage,omitempty"`
+
+	// ConfigurationProfileSizes and RouterSizes apply to Neki backup restores only.
+	ConfigurationProfileSizes []ConfigurationProfileSize `json:"configuration_profile_sizes,omitempty"`
+	RouterSizes               []RouterSize               `json:"router_sizes,omitempty"`
 }
 
 // ListPostgresBranchesRequest encapsulates the request to list Postgres branches for a database.
diff --git a/internal/planetscale/postgres_branches_test.go b/internal/planetscale/postgres_branches_test.go
index ca5a0e560..ee5785011 100644
--- a/internal/planetscale/postgres_branches_test.go
+++ b/internal/planetscale/postgres_branches_test.go
@@ -676,6 +676,72 @@ func TestPostgresBranches_ResizeParameterValidationError(t *testing.T) {
 	c.Assert(psErr.Code, qt.Equals, ErrInvalid)
 }
 
+func TestPostgresBranches_CreateWithNekiRestoreSizes(t *testing.T) {
+	c := qt.New(t)
+
+	replicas := 2
+	zeroReplicas := 0
+	replicasPerCell := 1
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(200)
+		c.Assert(r.Method, qt.Equals, http.MethodPost)
+
+		var body map[string]any
+		err := json.NewDecoder(r.Body).Decode(&body)
+		c.Assert(err, qt.IsNil)
+		c.Assert(body["backup_id"], qt.Equals, "bak_123")
+		c.Assert(body["cluster_name"], qt.Equals, nil)
+
+		profiles, ok := body["configuration_profile_sizes"].([]any)
+		c.Assert(ok, qt.IsTrue)
+		c.Assert(profiles, qt.HasLen, 2)
+		c.Assert(profiles[0], qt.DeepEquals, map[string]any{
+			"name":         "default",
+			"cluster_size": "PS_40",
+			"replicas":     float64(2),
+		})
+		c.Assert(profiles[1], qt.DeepEquals, map[string]any{
+			"name":     "analytics",
+			"replicas": float64(0),
+		})
+
+		routers, ok := body["router_sizes"].([]any)
+		c.Assert(ok, qt.IsTrue)
+		c.Assert(routers, qt.HasLen, 1)
+		c.Assert(routers[0], qt.DeepEquals, map[string]any{
+			"name":              "default",
+			"router_size":       "NKR_20",
+			"replicas_per_cell": float64(1),
+		})
+
+		out := `{"id":"postgres-test-branch","name":"postgres-test-branch","created_at":"2021-01-14T10:19:23.000Z","updated_at":"2021-01-14T10:19:23.000Z", "region": {"slug": "us-west", "display_name": "US West"}}`
+		_, err = w.Write([]byte(out))
+		c.Assert(err, qt.IsNil)
+	}))
+
+	client, err := NewClient(WithBaseURL(ts.URL))
+	c.Assert(err, qt.IsNil)
+
+	ctx := context.Background()
+	branch, err := client.PostgresBranches.Create(ctx, &CreatePostgresBranchRequest{
+		Organization: "my-org",
+		Database:     "postgres-test-db",
+		Name:         testPostgresBranch,
+		BackupID:     "bak_123",
+		ConfigurationProfileSizes: []ConfigurationProfileSize{
+			{Name: "default", ClusterSize: "PS_40", Replicas: &replicas},
+			{Name: "analytics", Replicas: &zeroReplicas},
+		},
+		RouterSizes: []RouterSize{
+			{Name: "default", RouterSize: "NKR_20", ReplicasPerCell: &replicasPerCell},
+		},
+	})
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(branch.Name, qt.Equals, testPostgresBranch)
+}
+
 func TestPostgresBranches_CreateWithStorage(t *testing.T) {
 	c := qt.New(t)
 
diff --git a/internal/planetscale/postgres_roles.go b/internal/planetscale/postgres_roles.go
index c52c0df67..0ad9d8592 100644
--- a/internal/planetscale/postgres_roles.go
+++ b/internal/planetscale/postgres_roles.go
@@ -9,8 +9,9 @@ import (
 	"time"
 )
 
-// PostgresRole represents a PostgreSQL role in PlanetScale.
+// PostgresRole represents a Postgres or Neki role in PlanetScale.
 type PostgresRole struct {
+	Type            string     `json:"type"`
 	ID              string     `json:"id"`
 	Name            string     `json:"name"`
 	AccessHostURL   string     `json:"access_host_url"`
@@ -23,6 +24,7 @@ type PostgresRole struct {
 	DisabledAt      *time.Time `json:"disabled_at"`
 	ExpiresAt       *time.Time `json:"expires_at"`
 	Expired         bool       `json:"expired"`
+	Ready           bool       `json:"ready"`
 }
 
 type postgresRolesResponse struct {
diff --git a/internal/planetscale/postgres_roles_test.go b/internal/planetscale/postgres_roles_test.go
index 8a224b684..06d69f3e3 100644
--- a/internal/planetscale/postgres_roles_test.go
+++ b/internal/planetscale/postgres_roles_test.go
@@ -16,6 +16,10 @@ import (
 
 const testRoleID = "AbC123xYz"
 
+func timePointer(value time.Time) *time.Time {
+	return &value
+}
+
 func TestResetDefaultRole(t *testing.T) {
 	c := qt.New(t)
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -273,6 +277,7 @@ func TestPostgresRoles_Get(t *testing.T) {
 		c.Assert(r.URL.Path, qt.Equals, "/v1/organizations/my-org/databases/my-db/branches/my-branch/roles/AbC123xYz")
 		w.WriteHeader(200)
 		out := fmt.Sprintf(`{
+    "type": "BranchRole",
     "id": "%s",
     "name": "test-role",
     "access_host_url": "test.planetscale.com",
@@ -280,6 +285,7 @@ func TestPostgresRoles_Get(t *testing.T) {
     "password": "secret-password",
     "username": "test-user",
     "with_replication": true,
+    "ready": true,
     "disabled_at": null,
     "expires_at": "2021-02-14T10:19:23.000Z",
     "expired": true,
@@ -306,6 +312,7 @@ func TestPostgresRoles_Get(t *testing.T) {
 
 	expiresAt := time.Date(2021, time.February, 14, 10, 19, 23, 0, time.UTC)
 	want := &PostgresRole{
+		Type:            "BranchRole",
 		ID:              testRoleID,
 		Name:            "test-role",
 		AccessHostURL:   "test.planetscale.com",
@@ -316,6 +323,59 @@ func TestPostgresRoles_Get(t *testing.T) {
 		CreatedAt:       time.Date(2021, time.January, 14, 10, 19, 23, 0, time.UTC),
 		ExpiresAt:       &expiresAt,
 		Expired:         true,
+		Ready:           true,
+	}
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(role, qt.DeepEquals, want)
+}
+
+func TestPostgresRoles_GetNekiLifecycleFields(t *testing.T) {
+	c := qt.New(t)
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		c.Assert(r.Method, qt.Equals, "GET")
+		c.Assert(r.URL.Path, qt.Equals, "/v1/organizations/my-org/databases/my-db/branches/my-branch/roles/AbC123xYz")
+		w.WriteHeader(200)
+		out := fmt.Sprintf(`{
+    "type": "NekiRole",
+    "id": "%s",
+    "name": "test-role",
+    "access_host_url": "test.planetscale.com",
+    "database_name": "test-db",
+    "username": "test-user",
+    "ready": false,
+    "expired": true,
+    "expires_at": null,
+    "disabled_at": "2026-08-19T12:00:00.000Z",
+    "created_at": "2021-01-14T10:19:23.000Z"
+}`, testRoleID)
+		_, err := w.Write([]byte(out))
+		c.Assert(err, qt.IsNil)
+	}))
+	defer ts.Close()
+
+	client, err := NewClient(WithBaseURL(ts.URL))
+	c.Assert(err, qt.IsNil)
+
+	role, err := client.PostgresRoles.Get(context.Background(), &GetPostgresRoleRequest{
+		Organization: "my-org",
+		Database:     "my-db",
+		Branch:       "my-branch",
+		RoleId:       testRoleID,
+	})
+
+	want := &PostgresRole{
+		Type:          "NekiRole",
+		ID:            testRoleID,
+		Name:          "test-role",
+		AccessHostURL: "test.planetscale.com",
+		DatabaseName:  "test-db",
+		Username:      "test-user",
+		CreatedAt:     time.Date(2021, time.January, 14, 10, 19, 23, 0, time.UTC),
+		DisabledAt:    timePointer(time.Date(2026, time.August, 19, 12, 0, 0, 0, time.UTC)),
+		Expired:       true,
+		Ready:         false,
 	}
 
 	c.Assert(err, qt.IsNil)
diff --git a/internal/roleutil/roleutil.go b/internal/roleutil/roleutil.go
index 6fd9d8f0a..4a2ff820c 100644
--- a/internal/roleutil/roleutil.go
+++ b/internal/roleutil/roleutil.go
@@ -8,6 +8,11 @@ import (
 	ps "github.com/planetscale/cli/internal/planetscale"
 )
 
+const (
+	roleReadyPollInterval = time.Second
+	roleReadyTimeout      = time.Minute
+)
+
 // Options represents the options to create a new Postgres role
 type Options struct {
 	Organization   string
@@ -46,6 +51,56 @@ func New(ctx context.Context, client *ps.Client, opts Options) (*Role, error) {
 	}, nil
 }
 
+// WaitUntilReady waits until a temporary role can accept connections.
+// The create response contains the only copy of the password, so this method
+// keeps the original role and only updates its readiness state.
+func (r *Role) WaitUntilReady(ctx context.Context) error {
+	if r.Role.Ready {
+		return nil
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, roleReadyTimeout)
+	defer cancel()
+
+	ticker := time.NewTicker(roleReadyPollInterval)
+	defer ticker.Stop()
+
+	return r.waitUntilReady(ctx, ticker.C)
+}
+
+func (r *Role) waitUntilReady(ctx context.Context, ticks <-chan time.Time) error {
+	if r.Role.Ready {
+		return nil
+	}
+
+	req := &ps.GetPostgresRoleRequest{
+		Organization: r.opts.Organization,
+		Database:     r.opts.Database,
+		Branch:       r.opts.Branch,
+		RoleId:       r.Role.ID,
+	}
+
+	for {
+		select {
+		case <-ctx.Done():
+			return fmt.Errorf("waiting for role %s to become ready: %w", r.Role.ID, ctx.Err())
+		case <-ticks:
+			if err := ctx.Err(); err != nil {
+				return fmt.Errorf("waiting for role %s to become ready: %w", r.Role.ID, err)
+			}
+
+			role, err := r.client.PostgresRoles.Get(ctx, req)
+			if err != nil {
+				return fmt.Errorf("checking role readiness: %w", err)
+			}
+			if role.Ready {
+				r.Role.Ready = true
+				return nil
+			}
+		}
+	}
+}
+
 // Cleanup deletes the temporary role with an optional successor
 func (r *Role) Cleanup(ctx context.Context, successor string) error {
 	return r.client.PostgresRoles.Delete(ctx, &ps.DeletePostgresRoleRequest{
diff --git a/internal/roleutil/roleutil_test.go b/internal/roleutil/roleutil_test.go
new file mode 100644
index 000000000..9d92a6e47
--- /dev/null
+++ b/internal/roleutil/roleutil_test.go
@@ -0,0 +1,106 @@
+package roleutil
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/planetscale/cli/internal/mock"
+	ps "github.com/planetscale/cli/internal/planetscale"
+)
+
+func TestWaitUntilReadyReturnsImmediatelyWhenReady(t *testing.T) {
+	role := newTestRole(t, &ps.PostgresRole{ID: "role-id", Ready: true}, func(context.Context, *ps.GetPostgresRoleRequest) (*ps.PostgresRole, error) {
+		t.Fatal("Get should not be called for a ready role")
+		return nil, nil
+	})
+
+	if err := role.WaitUntilReady(t.Context()); err != nil {
+		t.Fatalf("WaitUntilReady: %v", err)
+	}
+}
+
+func TestWaitUntilReadyPollsUntilReady(t *testing.T) {
+	getCalls := 0
+	role := newTestRole(t, &ps.PostgresRole{ID: "role-id", Password: "secret"}, func(_ context.Context, req *ps.GetPostgresRoleRequest) (*ps.PostgresRole, error) {
+		getCalls++
+		if req.Organization != "org" || req.Database != "db" || req.Branch != "main" || req.RoleId != "role-id" {
+			t.Fatalf("unexpected request: %+v", req)
+		}
+		return &ps.PostgresRole{ID: "role-id", Ready: getCalls == 2}, nil
+	})
+
+	ticks := make(chan time.Time, 2)
+	ticks <- time.Now()
+	ticks <- time.Now()
+	if err := role.waitUntilReady(t.Context(), ticks); err != nil {
+		t.Fatalf("waitUntilReady: %v", err)
+	}
+	if getCalls != 2 {
+		t.Fatalf("Get calls = %d, want 2", getCalls)
+	}
+	if !role.Role.Ready {
+		t.Fatal("role was not marked ready")
+	}
+	if role.Role.Password != "secret" {
+		t.Fatalf("password = %q, want create-response password", role.Role.Password)
+	}
+}
+
+func TestWaitUntilReadyReturnsAPIError(t *testing.T) {
+	wantErr := errors.New("api unavailable")
+	role := newTestRole(t, &ps.PostgresRole{ID: "role-id"}, func(context.Context, *ps.GetPostgresRoleRequest) (*ps.PostgresRole, error) {
+		return nil, wantErr
+	})
+
+	ticks := make(chan time.Time, 1)
+	ticks <- time.Now()
+	err := role.waitUntilReady(t.Context(), ticks)
+	if !errors.Is(err, wantErr) {
+		t.Fatalf("error = %v, want wrapped API error", err)
+	}
+}
+
+func TestWaitUntilReadyReturnsContextError(t *testing.T) {
+	role := newTestRole(t, &ps.PostgresRole{ID: "role-id"}, func(context.Context, *ps.GetPostgresRoleRequest) (*ps.PostgresRole, error) {
+		t.Fatal("Get should not be called after cancellation")
+		return nil, nil
+	})
+
+	ctx, cancel := context.WithCancel(t.Context())
+	cancel()
+	err := role.waitUntilReady(ctx, make(chan time.Time))
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("error = %v, want context cancellation", err)
+	}
+}
+
+func TestWaitUntilReadyReturnsTimeoutError(t *testing.T) {
+	role := newTestRole(t, &ps.PostgresRole{ID: "role-id"}, func(context.Context, *ps.GetPostgresRoleRequest) (*ps.PostgresRole, error) {
+		t.Fatal("Get should not be called after the deadline")
+		return nil, nil
+	})
+
+	ctx, cancel := context.WithDeadline(t.Context(), time.Now().Add(-time.Second))
+	defer cancel()
+	err := role.waitUntilReady(ctx, make(chan time.Time))
+	if !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatalf("error = %v, want deadline exceeded", err)
+	}
+}
+
+func newTestRole(t *testing.T, created *ps.PostgresRole, getFn func(context.Context, *ps.GetPostgresRoleRequest) (*ps.PostgresRole, error)) *Role {
+	t.Helper()
+
+	service := &mock.PostgresRolesService{GetFn: getFn}
+	return &Role{
+		Role:   created,
+		client: &ps.Client{PostgresRoles: service},
+		opts: Options{
+			Organization: "org",
+			Database:     "db",
+			Branch:       "main",
+		},
+	}
+}
diff --git a/internal/sqlquery/session.go b/internal/sqlquery/session.go
index 017074c7e..db3184cf7 100644
--- a/internal/sqlquery/session.go
+++ b/internal/sqlquery/session.go
@@ -16,7 +16,7 @@ import (
 // the connection and clean up the ephemeral credentials.
 type Session struct {
 	// Kind is the database kind as reported by the API: "mysql",
-	// "postgresql", or "horizon".
+	// "postgresql", "horizon", or "neki".
 	Kind string
 
 	db      *sql.DB
@@ -70,7 +70,7 @@ func NewSession(ctx context.Context, ch *cmdutil.Helper, opts Options) (*Session
 	switch string(dbInfo.Kind) {
 	case "mysql":
 		db, cleanup, err = openMySQL(ctx, ch, opts, role)
-	case "postgresql", "horizon":
+	case "postgresql", "horizon", "neki":
 		pgDB := opts.PostgresDB
 		if pgDB == "" {
 			pgDB = "postgres"
diff --git a/internal/sqlquery/sqlquery.go b/internal/sqlquery/sqlquery.go
index 681a6f12b..6ff87d82b 100644
--- a/internal/sqlquery/sqlquery.go
+++ b/internal/sqlquery/sqlquery.go
@@ -120,7 +120,7 @@ func Execute(ctx context.Context, ch *cmdutil.Helper, opts Options) (*Result, er
 	switch string(dbInfo.Kind) {
 	case "mysql":
 		outcome, err = queryMySQL(ctx, ch, opts, role)
-	case "postgresql", "horizon":
+	case "postgresql", "horizon", "neki":
 		pgDB := opts.PostgresDB
 		if pgDB == "" {
 			pgDB = "postgres"
@@ -281,6 +281,16 @@ func openPostgres(ctx context.Context, ch *cmdutil.Helper, opts Options, pgDB st
 		_ = pgRole.Cleanup(cleanupCtx, successor)
 	}
 
+	if !pgRole.Role.Ready {
+		end := ch.Printer.PrintProgress("Waiting for role to become ready...")
+		err = pgRole.WaitUntilReady(ctx)
+		end()
+		if err != nil {
+			cleanupRole()
+			return nil, nil, err
+		}
+	}
+
 	username := pgRole.Role.Username
 	if opts.Replica {
 		username = username + "|replica"
diff --git a/internal/sqlquery/sqlquery_test.go b/internal/sqlquery/sqlquery_test.go
index 4c04a3331..74a4786ff 100644
--- a/internal/sqlquery/sqlquery_test.go
+++ b/internal/sqlquery/sqlquery_test.go
@@ -2,10 +2,14 @@ package sqlquery
 
 import (
 	"context"
+	"errors"
 	"testing"
 
 	"github.com/planetscale/cli/internal/cmdutil"
 	"github.com/planetscale/cli/internal/config"
+	"github.com/planetscale/cli/internal/mock"
+	ps "github.com/planetscale/cli/internal/planetscale"
+	"github.com/planetscale/cli/internal/printer"
 )
 
 func TestIsReadQuery(t *testing.T) {
@@ -111,3 +115,62 @@ func TestExecuteValidation(t *testing.T) {
 		})
 	}
 }
+
+func TestOpenPostgresCleansUpRoleWhenReadinessWaitIsCanceled(t *testing.T) {
+	getCalls := 0
+	deleteCalls := 0
+
+	roles := &mock.PostgresRolesService{
+		CreateFn: func(_ context.Context, req *ps.CreatePostgresRoleRequest) (*ps.PostgresRole, error) {
+			if req.Organization != "org" || req.Database != "database" || req.Branch != "main" {
+				t.Fatalf("unexpected create request: %+v", req)
+			}
+			return &ps.PostgresRole{ID: "role-id", Ready: false}, nil
+		},
+		GetFn: func(_ context.Context, req *ps.GetPostgresRoleRequest) (*ps.PostgresRole, error) {
+			getCalls++
+			t.Fatalf("unexpected readiness request: %+v", req)
+			return nil, nil
+		},
+		DeleteFn: func(_ context.Context, req *ps.DeletePostgresRoleRequest) error {
+			deleteCalls++
+			if req.Organization != "org" || req.Database != "database" || req.Branch != "main" || req.RoleId != "role-id" {
+				t.Fatalf("unexpected delete request: %+v", req)
+			}
+			return nil
+		},
+	}
+
+	format := printer.JSON
+	ch := &cmdutil.Helper{
+		Printer: printer.NewPrinter(&format),
+		Client: func() (*ps.Client, error) {
+			return &ps.Client{PostgresRoles: roles}, nil
+		},
+	}
+
+	ctx, cancel := context.WithCancel(t.Context())
+	cancel()
+
+	db, cleanup, err := openPostgres(ctx, ch, Options{
+		Organization: "org",
+		Database:     "database",
+		Branch:       "main",
+	}, "postgres", cmdutil.ReaderRole)
+
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("error = %v, want context cancellation", err)
+	}
+	if db != nil {
+		t.Fatalf("db = %v, want nil", db)
+	}
+	if cleanup != nil {
+		t.Fatal("cleanup is not nil")
+	}
+	if getCalls != 0 {
+		t.Fatalf("readiness checks = %d, want 0", getCalls)
+	}
+	if deleteCalls != 1 {
+		t.Fatalf("role deletions = %d, want 1", deleteCalls)
+	}
+}