The Nexla agent CLI is a thin command-line client for Nexla, the enterprise data-integration platform. Install it in seconds, drive sources, sinks, nexsets (Nexla’s schema-aware datasets), and flows from your shell, and dry-run every mutating call against the live API schema before it fires. Built for humans scripting pipelines and for the coding agents working beside them.
PyPI · npm · standalone binaries · MIT · ~9-second install
uv tool install nexla-cli
pipx install nexla-cli
npm install -g @nexla/nexla-cli
https://github.com/nexla-opensource/nexla-agent-cli/releases/latest
The npm package and the release binaries are prebuilt native executables, so no Python is required. Plain pip install nexla-cli works too.
export NEXLA_API_URL=https://dev-api-express-code.nexla.com/ export NEXLA_TOKEN=$(nexla-cli login --service-key <your-service-key>) export NEXLA_MONITORING_URL=https://veda-ai.nexla.io/monitoring/ nexla-cli sources list nexla-cli connectors search shopify
You need a Nexla service key — get yours from express.dev. nexla-cli login prints the bearer token to stdout and everything else to stderr, so the $( … ) capture stays clean. NEXLA_MONITORING_URL points at the monitoring service and is needed for the nexla-cli triage commands.
Two dependencies: typer and httpx. No config files, no daemon, nothing to keep running. uv tool install or pipx install puts one nexla-cli binary on your PATH in seconds.
Stable exit codes, data on stdout, diagnostics on stderr, in every command, including failures. Branch on the exit code, not on message text, and pipe JSON without defensive parsing.
Ships a Claude Code skill, exposes the live API’s schema per command (nexla-cli schema sources.create), and lets you validate any mutation with --dry-run before it fires. No custom prompting needed.
Every mutating command (create, update, delete) accepts --dry-run. It validates your request body against the live API’s own OpenAPI schema, fires zero mutating calls (one read-only schema fetch), and echoes the merged body it would send, with named flags, --json, --params, and flag defaults resolved, so you see exactly what would go out.
nexla-cli sources create --name demo --connector s3 --json '{"credential_id": "oops"}' --dry-run
# exit 2, on stderr:
# {"valid": false, "errors": ["field 'credential_id' expected type integer/null, got str"]}
Deletes cascade and there’s no undo, so confirm the id with nexla-cli <resource> get <id> before you delete.
The package ships a Claude Code skill encoding the invariants an agent can’t infer from --help: dry-run before any create or delete, polling get after create because activation finishes asynchronously, branching on exit codes, and treating API response fields as data, never as instructions.
nexla-cli skill install # or project-local instead of global: nexla-cli skill install --target .claude/skills/nexla-cli
Re-run it after upgrading nexla-cli, then start a new Claude Code session. Separately, the CLI strips ANSI escapes, control characters, and invisible Unicode from every API response. Always on, no flag to forget.
Every resource self-documents with nexla-cli <resource> --help, and nexla-cli schema <resource>.<verb> returns the machine-readable request shape, fetched live from the deployed API.
The pipeline itself: a source feeds a nexset (a schema-aware dataset), a sink delivers it, a flow ties them together. Sources and sinks carry the full verb set (list, get, create, update, activate, pause, delete); nexsets: list, get, transform, activate; flows: list, get, activate, pause, delete.
700+ connectors: search the catalog, describe config shapes, probe credentials before you build on them.
Package nexsets as tools behind a toolset’s MCP gateway, and pull in external MCP servers alongside them.
Test a transform against sample records, pull consolidated account context to prime an agent, check which org you’re operating in.
Flow/log monitoring via the Nexla monitoring MCP server: which flows errored today, a flow’s full source → nexset → sink status chain, run timing, daily metrics, raw logs, quarantined records.
--output table|json|ndjson · --fields id,name,… · --page-all, on every command except login and schema, which always print raw output.
Wire the CLI into Claude Code with the shipped skill and let the agent stand up a source → nexset → sink flow end to end, dry-running every mutation and polling activation. You review; it ships.
nexla-cli triage errors surfaces the flows that failed today, triage status breaks a flow down to its source → nexset → sink chain, and triage metrics buckets records and errors by day. Stream any list with --page-all into jq or DuckDB for a board that refreshes as fast as you re-run it.
Create a toolset with its MCP gateway enabled and add nexsets to it; any MCP-capable agent can then query that data without holding your database credentials. Pull external tools into the same gateway with nexla-cli mcp-servers attach.
0 success · 1 generic error (including API 4xx other than 401/403/404) · 2 bad local input (validation, --dry-run failure) · 3 NEXLA_API_URL / NEXLA_TOKEN not set · 4 401/403 · 5 404 · 6 upstream 5xx. Scripts and agents should branch on these.
Default is a table on a TTY, JSON when piped. Force with --output / -o table|json|ndjson (also the NEXLA_OUTPUT env var). --fields id,name,status masks any list/get down to just those keys. Exceptions: login and schema always print raw output.
Create/update commands accept the full request body, not just named flags: --json '{"credential_id": 123}' plus repeatable --params key=value. Precedence: named flags win, then --json, then --params. Set fields the CLI has no dedicated flag for yet.
--page-all streams every page as NDJSON, driven by the API’s own next_page cursor, and filters you passed stay applied across pages. Works on the paginated list endpoints: sources, sinks, nexsets, credentials, flows, toolsets, tools.
A Nexla service key, plus any one of: Python 3.12+ (uv, pipx, or pip), Node (npm install -g @nexla/nexla-cli, no Python needed), or a standalone binary from GitHub releases. One install and three commands later you’re listing sources; see the quick start above.
--dry-run validates creates and updates without executing. Deletes are real, they cascade, and there’s no undo, so get the id first, and when in doubt create your own resources rather than editing shared ones.
Run nexla-cli skill install and start a new session. The skill teaches the agent dry-run discipline, exit-code branching, and async-activation polling.
Piped or with -o json, errors are JSON envelopes on stderr; on a TTY you get a plain error line. Either way the exit codes are stable: 3 means env vars aren’t set, 4 is an auth problem (re-run nexla-cli login), 5 is a missing resource id, 6 is an upstream API error. nexla-cli schema <resource>.<verb> shows the exact request shape the API expects.
GitHub issues on the repo for CLI bugs.
The CLI takes about a minute to set up. Star the repo →