Try Cargo Without an Account: Browse Go-to-Market Actions, Dry Run One, Plan a Project

Yes, you can try Cargo without an account. With no sign-in and no API key, the cargo-ai CLI lists every connector and native action with its credit price, dry runs a connector or native action for free, and plans a project offline; the public MCP server at https://mcp.getcargo.io/public serves the same catalog to any agent. Running an action and deploying a project are what need an account.

1. Install the CLI #

npm install -g @cargo-ai/cli
cargo-ai --version   # 1.0.122 or later

This is Cargo the go-to-market platform, not Rust’s cargo. Signed-out commands arrived in version 1.0.122; an older install answers every command with “Not authenticated”. If the global install is not on your PATH, npx @cargo-ai/cli works in place of cargo-ai.

Every command below prints its JSON on stdout. Signed out, it also prints one line on stderr, so an agent parsing stdout is not affected:

Not signed in: reading the official integrations and their actions only. Sign up with `cargo-ai login --email you@company.com` (100 free credits, no card) to run one.

2. Browse every action and its price #

cargo-ai orchestration action list find work email

All query terms must match. Each result names the action, the integration, and the exact action object the other commands take:

{
  "query": "find work email",
  "totalMatches": 1,
  "results": [
    {
      "name": "Find work email",
      "description": "Find a person's work email",
      "integrationName": "Forager",
      "category": "enrichment",
      "credits": [
        {
          "config": { "jsonSchema": { "type": "object" } },
          "cost": 2,
          "type": "fixed"
        }
      ],
      "action": {
        "kind": "connector",
        "integrationSlug": "forager",
        "actionSlug": "findWorkEmail"
      }
    }
  ]
}

The credits array is the price, read from the catalog at the moment you run the command. It takes one of three shapes: fixed is cost credits per call, unit is cost per unit returned plus fixedCost per call, and package is cost per block of unitsCount units plus fixedCost. An action with no credits array costs no credits.

Narrow the list with --kind connector or --kind native, --integration-slug <slug>, --category enrichment (or sales, marketing, engagement and the rest), and --limit <n>. To read a whole integration instead:

cargo-ai connection integration list --summary           # slug, name and category of each
cargo-ai connection integration get hubspot              # its actions, schemas and prices
cargo-ai connection integration get-documentation hubspot

Signed out, these return the official integrations and Cargo’s native actions. --kind tool and --kind agent return nothing, because tools and agents belong to a workspace.

3. Dry run one action, for free #

Add --dry-run to action execute and nothing runs. The CLI reads the action’s definition, checks your --data against its input schema, prices the call, and prints a sample result in the shape of a finished run:

cargo-ai orchestration action execute \
  --action '{"kind":"connector","integrationSlug":"aiArk","actionSlug":"enrichCompany"}' \
  --data '{"domain":"example.com"}' \
  --dry-run

{
  "run": {
    "status": "success",
    "executions": [
      {
        "nodeSlug": "action",
        "title": "Enrich company",
        "status": "success",
        "creditsUsedCount": 0
      }
    ]
  },
  "runContext": {
    "action": {
      "name": "Example Inc",
      "domain": "example.com",
      "industry": "Software",
      "employee_count": 120,
      "country": "United States",
      "technologies": ["sample"]
    }
  },
  "runComputedConfigs": { "action": { "domain": "example.com" } },
  "dryRun": {
    "sample": true,
    "estimatedCredits": 0.01,
    "creditsFormula": "0.01 credits per call",
    "note": "Sample data generated from the output schema. Nothing ran and no credits were used."
  }
}

The runContext.action above is shortened; the real one carries every field the action’s output schema declares. Read it for its shape, not its values: they are generated from the schema, and no provider was called. What the dry run does check for real:

• Your inputs. --data that does not match the action’s input schema fails with the missing or wrong fields, for example {"errors":["Missing required field: linkedinUrl"]}, which is the same mistake a real run would reject.
• The price. estimatedCredits is the price of one call for these inputs. For a metered action, it is the price of one unit or one block of units, and creditsFormula says what it scales with.

Two limits. A dry run covers connector and native actions only: a tool or an agent runs a workspace’s own workflow, so only a real run shows its output. And an action whose output depends on its configuration (which object type, which sheet) has no fixed shape to sample, so the dry run says so instead of inventing one.

4. Plan a project offline #

A Cargo project declares a workspace in TypeScript (models, plays, agents, connectors) and is deployed with a plan and apply, like infrastructure code. You can write one and plan it before the workspace exists:

cargo-ai project init acme-gtm
cd acme-gtm
npm install              # the project's own dependencies
cargo-ai project types   # typed integration actions and connector configs
cargo-ai project check   # validate every resource, no API calls
cargo-ai project plan    # the diff

Signed out, each step tells you what it skipped:

• types writes types for the official integrations: their actions, connector and extractor configs, and agent triggers. Model columns, language models and your connectors are read from a workspace, so those types arrive when you sign in and re-run cargo-ai project types.
• plan diffs against the state the project last deployed. With no state yet, every resource plans as a create. A project already bound to a workspace plans against the last cached read of its state, and says it may be stale. The per-record DNS diff of a domain is skipped, because it is read from the live zone.
• check and info never call the API, signed in or not.

cargo-ai project deploy is the step that needs an account.

5. Browse the catalog from any agent over MCP #

For an agent without a shell, or one you do not want installing a CLI, Cargo serves the action catalog as an MCP server that needs no token:

https://mcp.getcargo.io/public

Claude Code:

claude mcp add --transport http cargo-public https://mcp.getcargo.io/public

Cursor, in ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project):

{
  "mcpServers": {
    "cargo-public": {
      "url": "https://mcp.getcargo.io/public"
    }
  }
}

There is no sign-in prompt. The server has two tools, with the same names and schemas as on the authenticated server:

• search_actions finds connector and native actions, each with its price in credits[].cost, exactly like action list above.
• get_action_schema returns an action’s input schema, and its output schema when the action declares a fixed one.

It runs nothing and spends nothing. Workspace tools and agents are not in it, an Authorization header sent to it is ignored, and requests are rate-limited per address. Because both servers share tool names, an agent that learned the catalog here calls https://mcp.getcargo.io/mcp the same way once you sign in.

Sign up when you are ready #

Sign-up is the sign-in command. It runs in the terminal, with no browser and no card:

cargo-ai login --email you@company.com                 # sends a code
cargo-ai login --email you@company.com --code 123456   # creates the account on first use
cargo-ai whoami

A new account starts with 100 free credits and no card, per the CLI’s sign-up notice. Then everything above carries over:

• Run the action you dry ran. The same command without --dry-run runs it and bills the credits; add --wait-until-finished to get back the finished run whose shape the dry run showed you.
• Deploy the project. Re-run cargo-ai project types for the workspace types, then cargo-ai project plan for a live diff and cargo-ai project deploy.
• Switch the MCP server. Point your client at https://mcp.getcargo.io/mcp, which signs you in with OAuth and adds execute_action, batches and your data models.

The full setup for a coding agent, skills included, is in run go-to-market from Claude Code and run go-to-market from Codex, Cursor or OpenCode.

Frequently asked questions #

Can I try Cargo without an account?

Yes, for everything that does not run or deploy. Without an account, cargo-ai orchestration action list shows every connector and native action with its credit price, cargo-ai orchestration action execute --dry-run returns a free sample result and the price of one call, and cargo-ai project plan plans a project offline. The MCP server at https://mcp.getcargo.io/public serves the same catalog with no token.

Is there a demo API key or a sandbox workspace?

No. Signed-out commands read the public catalog, and nothing signed out can run an action or hold data. To run anything, create an account with cargo-ai login --email you@company.com.

Does a dry run cost credits?

No. A dry run calls no provider and creates no run: it validates your inputs against the action’s schema, prices the call, and generates a sample from the output schema. creditsUsedCount is 0 and the result is marked "dryRun".

How do I see what a Cargo action costs before signing up?

Run cargo-ai orchestration action list <keywords> and read the credits array on each result, or call search_actions on https://mcp.getcargo.io/public. For the price of one call with your inputs, run the action with --dry-run and read dryRun.estimatedCredits.

Can I deploy a Cargo project without an account?

No. init, types, check, info and plan work signed out, so you can write and validate a project first. cargo-ai project deploy needs a signed-in workspace to deploy to.