Visa CLI is a closed-beta command line tool, built by Visa's Crypto Labs division, that lets developers and their AI agents make programmatic card payments without pre-funded accounts or per-service API key management. Developers authenticate through GitHub, wait for approval, and then their terminal-resident agents can purchase paid APIs, datasets, and digital services inline with the code that triggered them.
​

Visa built a CLI because terminal-resident AI agents cannot pause mid-execution to fill out a checkout form or rotate API keys. By attaching a card credential to the development environment itself, Visa lets an agent pay for paid APIs the instant it needs them, with the developer billed downstream through the existing Visa network.
​

For decades, paying for digital services as a developer meant the same ritual: open an account, enter a card, generate API keys, store them securely, and reconcile a dashboard per provider. Each paid endpoint added another credential set and another billing relationship.
​

AI coding agents broke that workflow. When an agent in your terminal needs to call a paid image-generation API or query a proprietary dataset, it cannot pause to fill out a payment form. The agent needs programmatic money movement at the moment of need, not after a human approves an invoice.
​

Visa CLI's answer is to attach a payment credential to the development environment itself. The agent authenticates once, the transaction clears through Visa's network, and the developer gets billed. No per-service signup. No pre-funded wallet to top up.
​

A Worldpay survey cited by Very Good Security found 59% of shoppers aged 18 to 34 are comfortable with an AI agent browsing and shopping on their behalf. The demand side is moving fast, and developer infrastructure has to follow.
​

Visa CLI is not just a payments product. It is the first card-network admission that the terminal is now a checkout surface, and the developer execution layer is where the next wave of commerce gets wired. Browser checkout, chat checkout, and CLI checkout are now three peer surfaces, each backed by different rails.
​

For most of the web's history, commerce happened in one place: the browser checkout page. A human typed a card, clicked a button, and a form POST cleared the transaction. Chat checkout, launched commercially with OpenAI's "Buy it in ChatGPT" and PayPal-Perplexity integrations, added a second surface. The buyer is still a human, but the interaction is conversational.
​

CLI checkout is the third surface, and it is the first one where the buyer is not a person at all. The agent does not see a button. It sees a function. When Visa, the largest card network in the world, ships a tool that treats the terminal as a payment endpoint, it is endorsing a structural shift, not a niche workflow.
​

For developers building financial orchestration or settlement features into their apps, this is the cue to design for software-initiated transactions as a first-class case, not an edge case bolted onto a human flow.
​

Visa CLI works by routing terminal-issued payment intents through Visa's tokenized card infrastructure under the Intelligent Commerce platform. Developers authenticate via GitHub, receive a token bound to their environment, and the CLI signs and forwards transactions to Visa, which clears them against the developer's underlying funding source.
​

Visa CLI is currently gated through a GitHub-based signup at visacli.sh. Based on the public documentation, the flow looks roughly like this:

An illustrative command flow from a builder's seat looks something like:
​

$ visa login (opens GitHub OAuth, exchanges a short-lived token)
​$ visa pay --api image-gen.example.com --amount 0.04 --purpose "render hero asset"
​$ visa log (returns a transaction ID, amount, merchant, and timestamp)
​

The exact commands and flags will move during beta. The pattern, though, is the standard CLI ergonomics developers already use for cloud, GitHub, and package tooling, applied to card payments. The official site highlights three initial use cases:
​

Image generation on demand. An agent calls a paid image-gen API, and the CLI clears the charge without a separate signup per provider.
​

Music generation endpoints. Audio and music generation services become accessible programmatically, with billing handled inline.
​

Proprietary datasets. Market data, analytics, and research behind paywalls become reachable without managing one subscription per provider.
​

Visa CLI sits inside Visa Intelligent Commerce, the company's broader platform for letting AI agents browse, shop, and pay on behalf of users. Intelligent Commerce supplies the tokenized credentials, authentication, and spending controls. The CLI is the developer-facing surface that wires those primitives into the terminal.
​

The platform itself is documented at developer.visa.com. According to Visa's December 2025 announcement, more than 100 partners are building on Visa Intelligent Commerce, with over 30 in the sandbox and 20-plus agent integrations live.
​

Intelligent Commerce provides tokenized digital credentials, authentication, spending controls, and privacy-aware personalization. These are the same primitives that underpin the CLI: a machine-initiated transaction clears through the existing Visa rails, but with extra metadata identifying the agent and its authorization envelope.
​

For developers building applications that involve financial orchestration or settlement, the implication is that the transaction initiator is increasingly software, and the network has to model that explicitly rather than pretending the agent is just another anonymous browser session.
​

The Trusted Agent Protocol is Visa's open framework, released in October 2025 with Cloudflare, that uses cryptographic signatures to verify an AI agent's identity, authorization, and intent at the moment of a transaction. It is the trust layer that makes CLI transactions possible without exposing merchants to indistinguishable bot traffic.
​

If an AI agent walks into a digital storefront and tries to buy something, the merchant needs a way to know the agent is authorized and acting for a real consumer. Visa's answer is the Trusted Agent Protocol.
​

The protocol bundles several components. Agent intent indicators tell the merchant whether the agent is browsing or purchasing. Consumer recognition objects let the agent pass identifiers like loyalty accounts or device fingerprints. Payment credential handling ensures card data flows through established secure channels.
​

For Visa CLI users, the same trust framework applies. When a coding agent makes a purchase through the CLI, Visa's infrastructure checks the agent's identity and confirms the transaction is inside the developer's authorized envelope.
​

The Trusted Agent Protocol is open source on GitHub, and Stripe, Shopify, Adyen, Microsoft, and Coinbase have provided feedback on the specification. Akamai integrated its bot-detection and behavioral-intelligence stack into the protocol in late 2025, per Visa's December 2025 press release, adding another verification layer for merchants distinguishing real agents from malicious bots.
​

Visa's MCP server is a Model Context Protocol implementation that lets AI agents connect to Visa Intelligent Commerce APIs through the same protocol Claude and other LLMs already use for tool calls. It is the deeper integration surface for developers who want richer payment workflows than the CLI exposes.
​

MCP is an open standard for letting AI models call external systems through a consistent interface. The Visa MCP repository includes Node.js and TypeScript client implementations, authentication patterns, and workflow examples. Agents can enroll cards, initiate purchase instructions, retrieve payment credentials, and manage transactions through MCP tool calls.
​

Alongside the MCP server, Visa launched the Acceptance Agent Toolkit in pilot. Built on the MCP server, the toolkit lets developers and non-technical users trigger payment actions with plain-language commands. Users can create invoices, generate payment links, and manage acceptance workflows without writing API integration code.
​

The CLI, the MCP server, and the toolkit together reflect a single pattern: meet builders where they work, whether that is a terminal, an IDE, or a chat interface.
​

Visa CLI competes for mindshare with a handful of agent payment stacks built on different surfaces and rails. Stripe's Agent Toolkit and ACP target checkout, Coinbase's x402 targets the HTTP layer with stablecoins, and Skyfire and Payman target wallet-style API key issuance. Each picks a different point in the stack to absorb the transaction.
​

Each approach is a different bet on where agentic payments should live in the stack. Visa CLI bets on the terminal, Stripe on the checkout layer, x402 on the HTTP request itself, and Skyfire on a hosted wallet abstraction. A developer who understands all four will design more capable agents than one locked into a single pattern. Stripe launched ACP with Salesforce, Squarespace, and PwC. Google introduced the Universal Commerce Protocol at NRF 2026. The space is layered, not winner-take-all.
​

Card rails through Visa CLI are the right choice when an agent is paying merchants that already accept cards, billing has to roll up to a human accounting system, and transactions are denominated in fiat. Programmable stablecoin rails are the right choice when an agent needs sub-cent fees, instant final settlement, or cross-border payouts where card acceptance is thin or expensive.
​

In practice the decision is rarely either-or. A serious agent stack will reach for both. The useful question is which rail fits a given transaction:

Total stablecoin supply sits at $315.3B as of Q2 2026, per DeFiLlama, with USDT at $187.2B and USDC at $75.6B. That supply is the float that programmable rails draw on. Card networks remain larger by transaction volume, but the gap on agent-native rails is closing fastest at the API-call end of the spectrum.
​

The Visa CLI beta has real constraints that builders should plan around. Access is gated behind GitHub signup and Visa approval, spending limits cap how much an agent can move per period, regional availability tracks Visa's existing markets, and Visa collects metadata on agent transactions for fraud and product analytics. None of this is unusual for a beta, but production agents should not depend on it yet.
​

A few practical realities surface in the documentation and partner posts. The signup funnel runs through GitHub OAuth, which means an agent or environment without a linked GitHub identity cannot onboard. Visa applies beta spending limits to each approved account, with limits not publicly disclosed but understood to be low enough to discourage production migration. Regional rollout is incremental; Visa's December 2025 announcement projected broader rollouts across Asia-Pacific and Europe in early 2026, which implies parts of the world are not in scope yet.
​

Visa also logs metadata on agent-initiated transactions: agent identifier, intent flag, amount, merchant, and Trusted Agent Protocol envelope. This is consistent with how card networks already treat any tokenized transaction, but builders should treat their agent's transaction history as data Visa holds and can analyze, not as a private ledger.
​

The posture for production use, then, is straightforward. Do not ship a paying agent on a closed beta. Use Visa CLI to validate the workflow, write a thin adapter so the same agent can switch to a Stripe ACP, x402, or hosted-wallet backend later, and avoid hard-coupling business logic to any single beta provider's authentication model.
​

Agentic commerce is forcing payments infrastructure to treat software, not humans, as the default transaction initiator. Card networks, checkout providers, and onchain protocols are all racing to model agent identity, scoped authorization, and per-call settlement. Visa CLI is one signal inside that shift, not the shift itself.
​

At NRF 2026 in January, a live audience survey showed 75% of retail attendees were implementing or planning agentic commerce initiatives. Stripe launched its Agentic Commerce Suite, Google introduced its Universal Commerce Protocol, and OpenAI's "Buy it in ChatGPT" brought agentic purchasing into one of the most widely used AI interfaces.
​

The shared thread: payments infrastructure built for human-driven checkout cannot scale to machine-initiated transactions. Traditional checkout assumes a person filling forms and clicking buttons. When the buyer is software, those patterns become bottlenecks.
​

Whether the transaction clears through Visa CLI or routes stablecoin transfers across blockchains, the core requirement is the same. Money has to move as fast as the software requesting it. That is why projects focused on programmable payment infrastructure and networked money movement are gaining traction in parallel with card-network releases.
​

For developers in 2026, Visa CLI matters mostly as a signal: the largest card network now treats the terminal as a payment endpoint, and the infrastructure-level credential pattern is becoming the default for agent-driven services. The architectural choice is whether to design agents around composable payment rails or keep bolting on per-service API keys.
​

Several practical implications follow.
​

For agent developers, Visa CLI reduces the setup cost of connecting to paid services. Rather than managing separate billing per API, the CLI provides a single payment channel and a single reconciliation point.
​

For merchants and API providers, tools like Visa CLI, the Trusted Agent Protocol, and the MCP server create a standardized way to accept payments from AI agents. That matters for anyone running a paid API who wants to capture revenue from the growing population of coding agents.
​

For the broader developer ecosystem, command-line commerce validates the idea that payment should be a composable building block in the development stack, not a separate system requiring manual intervention.
​

The infrastructure powering stablecoin economies faces similar design pressure. Both traditional card networks and onchain payment systems converge on the same end state: software-initiated, real-time, programmable money movement.
​

Requesting Visa CLI access requires a GitHub account, approval from Visa's beta team, and acceptance of beta terms that include spending limits. The signup lives at visacli.sh, runs through GitHub OAuth, and ends with an approval email containing install instructions. There is no public general-availability timeline yet.

The beta is limited, and Visa has not published a public general-availability date. Per Visa's December 2025 announcement, hundreds of agent-initiated transactions have already cleared with partners, and broader rollouts across Asia-Pacific and Europe were projected for early 2026.
​

The questions below cover what most developers ask before requesting Visa CLI access: what the tool is, who built it, how to sign up, what it can pay for, what it costs, and how it relates to the rest of Visa's agent stack and to the broader agentic commerce landscape.
​

Visa CLI is a closed-beta command line tool built by Visa's Crypto Labs division that lets developers and AI agents make programmatic card payments from the terminal. It removes the need for pre-funded accounts and manual API key management when buying paid digital services.
​

Visa's Crypto Labs division created Visa CLI. It is part of Visa's broader Intelligent Commerce initiative, which provides infrastructure for AI agent-driven commerce.
​

Developers can request access at visacli.sh by signing up with a GitHub account. The tool is in closed beta with spending limits and a manual approval process.
​

Initial use cases include paying for image-generation APIs, music-generation endpoints, and proprietary datasets. Any paid digital service an AI agent needs to access while coding is a potential use case.
​

Visa CLI itself is a beta tool. Developers pay for the services and APIs their agent purchases through it, with transactions clearing through Visa's card network. Specific pricing and fee structures have not been publicly detailed for the beta.
​

Visa's Trusted Agent Protocol is an open framework that uses cryptographic signatures to verify AI agent identity and authorization during commerce interactions. It helps merchants distinguish authorized agents from bots.
​

Visa CLI is one tool inside the broader Visa Intelligent Commerce platform. Intelligent Commerce provides the tokenization, authentication, and spending controls that make agent-initiated payments secure and verifiable.
​

Visa released a Model Context Protocol server that lets AI agents connect to Intelligent Commerce APIs. Developers can use it to build agents that enroll cards, initiate purchases, and manage transactions through a standardized protocol that Claude and other LLMs already speak.
​