# Stripe Pay: Send Money to Another Business From the CLI With Just a Handle

> Source: <https://explainx.ai/blog/stripe-pay-cli-b2b-transfers-profile-handle-agents-guide-2026?utm_source=rss&utm_medium=feed&utm_campaign=blog>
> Published: 2026-10-29 00:00:00+00:00

Stripe announced `stripe pay` on October 27, 2026: a command that finds a company by its Stripe profile handle and sends it money, instantly, from your terminal. The launch post drew about 715K views on X in its first day. It matters beyond the demo because the same command was written to be driven by an AI agent, with confirmation steps built in. We read the Stripe CLI docs so you do not have to guess what ships today and what is still a promise.

The short version: it is a real, documented feature, but it is a **preview for eligible US and UK businesses**, not a switch every Stripe user can flip. This post covers who can use it, the exact commands, how the agent safeguards work, and where the announcement and the docs do not line up.

## TL;DR: the questions people ask first

| Question | Answer | 
|---|---|
| What is it? | A Stripe CLI plugin: `stripe pay [recipient] [amount] [currency]` sends an instant transfer to a business by Stripe profile handle. | 
| Who can use it? | Eligible US and UK businesses, in preview (per the [Stripe CLI docs](https://docs.stripe.com/cli/pay?ref=explainx) ). | 
| What do I need to send? | A funded Stripe Treasury financial account and a logged-in CLI. | 
| What does the recipient need? | A Treasury financial account, or a payout-enabled bank account linked to their Stripe profile. | 
| Which currencies? | `usd` ,`gbp` and`usdc` , same-currency only. | 
| Is it free? | Stripe's post says free. The review step in the CLI still returns a fee field, so check it. | 
| Can an agent run it? | Yes, with `--agent` or`--json` . Money does not move until a human-confirmed rerun with`--yes` . | 
| Available in India? | No. [Stripe profiles are not available in India](https://docs.stripe.com/get-started/account/profile.md?ref=explainx) . | 

## What did Stripe actually announce?

Stripe's account on X described it this way: "Introducing 'stripe pay', for instant business-to-business transfers. Find companies using their Stripe profile handle and send funds for free. Available in the Dashboard and CLI." A 23-second demo video showed the command line flow, and a follow-up pointed to the [stripe pay reference](https://docs.stripe.com/cli/pay?ref=explainx).

The reaction in the replies was mostly approval. One reply called handle-based B2B transfers "how it should've worked 10 years ago". Another joked that every bad actor would now add Stripe to their toolkit, which is a real concern and one we cover below under limits.

The mechanics are simple. Every business with a [Stripe profile](https://docs.stripe.com/get-started/account/profile.md?ref=explainx) gets a public handle that starts with `@`, for example `@stripe`. A handle uniquely identifies the business across Stripe. `stripe pay` resolves that handle to a recipient and routes a transfer over a Stripe rail, instead of you collecting bank details, sort codes or wallet addresses.

## How do you run it? The exact commands

Install the Stripe CLI (the profile docs point to version 1.43.3 or later and `npm install -g @stripe/cli`), then authenticate and confirm which account is active before any money moves:

```
stripe login
stripe whoami
```

Interactive use is the simplest. Run it with no arguments and the CLI asks for the recipient, amount and currency:

```
stripe pay
```

Or pass everything inline:

```
stripe pay @profile-handle 10.00 usd
stripe pay profile_... 10.00 usd
```

The second form uses a profile network ID instead of a handle. Two optional flags help with bookkeeping. `--internal-note` (50 ASCII characters or fewer) is never shown to the recipient. `--memo` (22 ASCII characters or fewer) is what the recipient sees. To test the whole flow without creating anything, add `--dry-run`:

```
stripe pay @profile-handle 10.00 usd \
  --financial-account fa_... \
  --internal-note "Invoice 1234" \
  --memo "PROFILE PAY" \
  --dry-run
```

If your account has several eligible financial accounts, an interactive session shows a selector. Scripts and agents should always pass `--financial-account` explicitly, because the source account must be open, eligible for network transfers and support the chosen currency.

## What does the sender and recipient setup look like?

This is where the "just send money" framing gets more specific. Both sides need Stripe infrastructure in place first.

| Role | Requirement | 
|---|---|
| Sender | Authenticated CLI, a Stripe profile, and a funded Treasury financial account | 
| Recipient | A Stripe profile, plus a Treasury financial account or a payout-enabled bank account linked to the profile | 
| Region | Eligible US and UK businesses (preview) | 
| Currencies | USD, GBP, USDC; same currency on both sides | 

If the authenticated account has no profile yet, an interactive session can create one. For scripts, pass `--create-profile-if-missing` together with `--profile-handle`, `--profile-display-name` and `--profile-email`. Profiles can also be created in the Dashboard under Stripe profile, where you pick a short handle and an optional logo, description and website.

Profiles are public by default. They appear on a profile page such as `profile.stripe.com/@stripe`, in Dashboard search, on Stripe-generated invoices and in Stripe Directory. A private profile drops out of search results, but anyone with the URL can still open the page.

## How does Stripe make it safe for AI agents?

This is the part that is relevant to builders. The docs for `stripe pay` read like they were written for an agent as much as for a person, and that is the point. Stripe ships a `stripe-pay` skill file alongside the command, in the same format covered in our [agent skills guide](https://explainx.ai/blog/what-are-agent-skills-complete-guide).

An AI agent handing a payment approval to a human before money moves with stripe pay

The documented agent flow has four steps:

1. Run `stripe whoami` to verify the active account. If auth fails, ask the human to run`stripe login` .
2. Run the command with the exact recipient, amount and currency, plus `--agent` . The CLI returns a`confirmation_required` response and**does not send money** .
3. Review the returned source account, recipient, amount, currency, fee, delivery timing, note and memo with the user.
4. Only after the user confirms, rerun the same command with `--yes` , passing`--financial-account` explicitly.

Two more guardrails stand out:

- **Do not guess the recipient.** If the user gives only a company name, the skill tells the agent to search[Stripe Directory](https://docs.stripe.com/directory.md?ref=explainx#agents) , show candidates, and make the user pick the exact handle.
- **Approval requests.** Some accounts return`status: approval_required` . The agent hands the human an`approval_url` , waits, and then runs the exact`next_step.command` . Resumable requests expire after 5 minutes, and an expired or rejected request must never be reused.

The design pattern is worth copying in your own agent tools: a dry-run by default, a machine-readable review object, a human confirmation step bound to the exact arguments, and a hard rule against changing arguments after approval. It is the same idea behind the spending limits in [Walmart's agent gateway](https://explainx.ai/blog/walmart-agent-gateway-mcp-agent-profiles-spending-limits-amazon-blocks-agents-2026) and the budget terms in [Shopify's agent checkout](https://explainx.ai/blog/shopify-shop-any-ai-agent-billion-listings-agent-pay-budget-terms-2026).

## Announcement vs docs: where they do not match

Reading the tweet and the reference side by side shows a few gaps worth knowing before you plan around this.

| Announcement says | Docs say | 
|---|---|
| Send funds "for free" | The agent review response includes a fee and delivery timing; confirm it for your account and rail | 
| Available in the Dashboard and CLI | The CLI plugin is a preview for eligible US and UK businesses | 
| Find companies by handle | Handle or `profile_` ID, and only recipients with a funded financial account or payout-enabled bank account | 
| Instant | The command says "instant transfer", while delivery timing is returned per transfer in the review step | 

None of this means the claim is false. It means the headline is the best case and the reference is the contract. If you are building on it, build on the reference.

## How is this different from what Stripe already had?

Stripe has had payouts, Treasury money movement and invoicing for years. What is new is the addressing model. Instead of exchanging account details through an invoice or a form, the identifier is a public handle, and the lookup layer (Stripe Directory) is something an agent can query without logging in.

That fits the larger direction we have been tracking: Stripe is building rails for software, not only for people. Our coverage of [Stripe Link's agent purchases growing 38x](https://explainx.ai/blog/stripe-link-agentic-transactions-38x-september-claimed-vs-verified-2026) looked at consumer-side agent spending. `stripe pay` is the business-side counterpart. A consumer agent buys a product with Link. A business agent pays a supplier, a contractor or an API vendor with a handle. The [Personal Agent Protocol work with Stripe, Meta, Walmart and Sierra](https://explainx.ai/blog/personal-agent-protocol-sierra-meta-walmart-stripe-open-standard-2026) sits at the same layer: shared identity and payment conventions so agents can transact across companies.

If you want to see a working agent payment flow on the consumer side, our [LangChain restock agent with Stripe Link](https://explainx.ai/blog/langchain-restock-agent-stripe-link-mpp-agent-payments-guide-2026) walkthrough is the closest hands-on reference.

## What are the limits and risks?

Honest limits, based on the docs:

- **Preview, narrow region.** US and UK only, and "eligible" businesses. Stripe has not published eligibility criteria in the reference we read.
- **Treasury required.** You need a funded Treasury financial account on the sending side. That is a bigger prerequisite than "have a Stripe account".
- **Same-currency only.** No FX through this command.
- **Irreversibility.** Instant transfers are hard to claw back. The same speed that makes the demo good makes a wrong handle expensive. Handles are unique, but a look-alike handle is exactly how a fraudster would try to redirect a payment.
- **Public directory.** Making a profile discoverable also makes your business a target for look-alike and impersonation attempts. Use a private profile if discoverability is not a goal.
- **Agent prompt injection.** An agent that reads invoices or emails can be told to pay a different handle. The`confirmation_required` step is only a safeguard if a human actually compares the recipient and amount, not if a second agent clicks yes.

For teams running coding or finance agents with CLI access, put a hard control around money commands. Our note on [Amex's intent framework for unauthorized agent purchases](https://explainx.ai/blog/amex-intent-intelligence-framework-ai-agents-unauthorized-purchases-2026) covers why intent checks matter once agents can spend. For a tool that blocks dangerous agent actions before they run, see [AgentBeam](https://agentbeam.com/?ref=explainx), from the explainx.ai team.

## What does this mean for what you build or pay?

If you build agent workflows that touch money, three takeaways:

1. **Treat payment commands as a privileged tool.** Wrap`stripe pay` so the agent can call`--agent` and`--dry-run` freely, but`--yes` is only reachable after a human step bound to the exact recipient, amount and currency.
2. **Store the handle, not the bank details.** If you pay the same vendors regularly, keep verified handles in a config the agent reads, so it never has to search a directory at run time.
3. **Log the review object.** The JSON returned by the review step is a ready-made audit record: source account, recipient, amount, fee, timing. Save it before you confirm.

If you run a business, the cost question is simple: compare the fee shown in the review step with what your current wire or ACH route costs you. Stripe says free; verify it on your own account before you move volume.

## How do you try it safely?

A cautious first run, in order:

1. Create or confirm your profile and handle in the Dashboard.
2. Run `stripe login` and`stripe whoami` to confirm the right account.
3. Run a dry-run with a small amount against a handle you control or trust.
4. Read the review JSON: recipient, amount, fee, timing.
5. Only then send a small real transfer without `--dry-run` , and confirm with the recipient that it arrived.

For agent use, give your agent the `stripe-pay` skill and the rule that it must stop at `confirmation_required`. The [MCP guide](https://explainx.ai/blog/what-is-mcp-model-context-protocol-guide) explains how to expose the same behavior as a gated tool if you prefer MCP over a shell command.

## Bottom line

`stripe pay` is a useful, documented step toward addressing businesses by a handle instead of bank details, and it is clearly designed for agents to operate with a human in the loop. It is also a preview with real prerequisites: a US or UK business, a Treasury account on each side, same-currency transfers and a fee line to read. Treat the tweet as the pitch and the CLI reference as the product, and put your own approval gate in front of `--yes`.

*Details are accurate as of October 29, 2026, based on Stripe's October 27 announcement and the Stripe CLI documentation. Eligibility, fees and supported regions may change as the preview expands.*