← Back to report Page 1 of 3
Full Transcript
Stripe - Sonnet Transcript
Report: Stripe - Universal Baseline Model: Sonnet 4.6 Tested: 2026-03-24 Agent CLI: Claude Code v2.1.81
Task 1
Discover
OperatorStep 1
I need to accept one-off credit card payments from customers via an API. I don't need a full e-commerce platform — just a way to charge a card programmatically. Evaluate Stripe as an option. Specifically: - What does Stripe offer that fits this need? - What are the API's main concepts I'd need to understand? - Is there a way to test without spending real money? Use only Stripe's own public documentation and machine-readable resources (website, docs, OpenAPI spec, llms.txt, MCP server) to answer. Do not rely on your training data.
ToolSearchTool Use
Input
Show input
{
"query": "select:WebFetch"
}ToolSearchTool Result
Result
Show output
[
{
"type": "tool_reference",
"tool_name": "WebFetch"
}
]WebFetchTool Use
Input
Show input
{
"url": "https://stripe.com/llms.txt",
"prompt": "Return the full content of this file"
}WebFetchTool Use
Input
Show input
{
"url": "https://docs.stripe.com/llms.txt",
"prompt": "Return the full content of this file"
}WebFetchTool Result
Result
Show output
# Stripe: Complete Web Content Overview This comprehensive resource document outlines Stripe's full suite of financial infrastructure products and services. ## Core Product Categories **Payments Solutions**: Stripe offers global payment acceptance through various channels including online, in-person, and embedded payment methods. The platform supports diverse payment techniques and helps businesses optimize transaction success rates. **Connect Platform**: Designed for marketplaces and platforms, this allows businesses to "embed payments into their products" with streamlined onboarding and payout capabilities. **Billing & Invoicing**: Automated tools handle recurring billing, usage-based pricing, and invoice generation without requiring code. **Compliance & Risk**: Services include tax automation, fraud prevention through Radar, identity verification, and financial connections for streamlined payments. **Financial Services**: Treasury, Capital, and Issuing products enable embedded banking functionality, lending access, and card distribution. **Data & Analytics**: Sigma and Data Pipeline tools provide reporting and warehouse integration for business insights. **Sustainability**: Climate program supports carbon removal technologies and integration. ## Key Features The platform emphasizes "no-code" solutions for businesses of varying sizes, from startups through enterprises. Resources span technical documentation, integration guides, and extensive educational content covering payment fundamentals, compliance requirements, and industry-specific implementations. Documentation links and support resources are provided throughout for detailed implementation guidance.
WebFetchTool Result
Result
Show output
# Stripe Documentation - Full Content This is the complete Stripe documentation index covering the following major sections: ## Core Topics **Payments & Checkout**: Instructions for accepting payments through Checkout Sessions API, Payment Intents API, and Payment Element. The documentation emphasizes using modern APIs rather than deprecated endpoints like the Charges API. **Billing & Subscriptions**: Tools for managing recurring revenue, including subscription creation, pricing models, usage-based billing, and customer management features. **Payment Methods**: Comprehensive coverage of global payment options including cards, bank transfers, wallets, buy-now-pay-later services (Affirm, Klarna, Afterpay), and local payment methods by region. **Link**: Feature allowing customers to save payment methods for faster checkout across Link-enabled businesses, with support for instant bank payments. **Connect**: Platform for building marketplaces and SaaS integrations, with emphasis on Accounts v2 API for new platforms managing multi-party fund flows. **Elements**: Prebuilt UI components for custom checkout flows, including Payment Element, Address Element, and various mobile payment solutions. ## Financial & Administrative Services **Invoicing**: Invoice creation, management, and automated collection with tax integration and customization options. **Treasury & Financial Accounts**: Embedded finance APIs for Connect platforms enabling fund holding, bill payments, and cash flow management. **Issuing**: Card issuance program tools for creating and managing physical and virtual cards. **Tax**: Automated sales tax, VAT, and GST calculation and collection across transactions and subscriptions. **Identity**: User identity verification supporting documents from 120+ countries with fraud prevention capabilities. ## Platform & Risk Management **Radar**: Real-time fraud detection using machine learning with customizable rules and risk controls. **Revenue Recognition**: Accrual accounting automation for GAAP/IFRS compliance with customizable rules and reporting. **Terminal**: In-person payment acceptance through certified card readers with unified online/offline management. **Capital**: Financing options for eligible Stripe users with platform integration capabilities. ## Developer Tools & Guidance The documentation provides guidance emphasizing: - Always verify current SDK versions via npm registry or PyPI before installation - Prefer Checkout Sessions API over deprecated Charges API - Use Payment Element instead of legacy Card Element - Leverage Confirmation Tokens for pre-intent card inspection - Enable dynamic payment methods through dashboard settings Additional resources include sample projects, testing guidance, dashboard features, and compliance checklists for going live.
WebFetchTool Use
Input
Show input
{
"url": "https://docs.stripe.com/payments/payment-intents",
"prompt": "Explain the PaymentIntent API: what it is, the key objects/concepts, and how a one-off card payment works end to end"
}WebFetchTool Use
Input
Show input
{
"url": "https://docs.stripe.com/testing",
"prompt": "How does Stripe's test mode work? What test card numbers are available? Is there a sandbox environment?"
}WebFetchTool Result
Result
Show output
# PaymentIntent API Overview ## What It Is The PaymentIntent API is Stripe's solution for handling complex payment workflows with status tracking throughout a payment's lifecycle. It manages payments from creation through completion and can trigger additional authentication steps when needed. ## Key Objects & Concepts **PaymentIntent**: The core object representing a single transaction. As stated, it "summarizes transaction details, such as supported payment methods, the amount to collect, and the desired currency." Each typically corresponds to one cart or customer session. **Client Secret**: A unique, sensitive key returned with the PaymentIntent. The documentation notes it "lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)." **Payment Methods**: Saved or provided payment details used to complete the transaction. **Idempotency Keys**: Prevent duplicate PaymentIntents for the same purchase. ## One-Off Card Payment Flow 1. **Server-side creation**: Your backend creates a PaymentIntent with amount and currency via the Stripe API 2. **Pass client secret**: The server securely sends only the client secret to your frontend (never the full object) 3. **Client confirmation**: The client uses Stripe.js with the client secret to confirm the payment 4. **Webhook monitoring**: Your server monitors webhooks to detect success or failure The documentation emphasizes that the client secret should not be "logged, embedded in URLs, or made accessible to anyone except the customer themselves."
WebFetchTool Result
Result
Show output
# Stripe Test Mode Overview ## Sandbox Environment Stripe provides a dedicated sandbox for testing. You can "access your sandboxes through the account selection in the Dashboard" where you can simulate transactions using test values without moving real money. ## Test Card Numbers Stripe offers numerous test card numbers organized by: - **Card brand**: Visa, Mastercard, American Express, Discover, Diners Club, JCB, UnionPay, etc. - **Card type**: Credit, debit, prepaid variants - **Geographic region**: Cards for North/Central/South America, Europe, Middle East, and Asia-Pacific For example, the basic Visa test card is **4242 4242 4242 4242**. For any test card, use any future expiration date and any 3-digit CVC (4 digits for American Express). ## Key Guidelines When testing, always use **test API keys** rather than live keys. The documentation explicitly warns: "do not use real card details" as this violates Stripe's service agreement. Test cards "accept the role of fake credit cards" to simulate various scenarios including successful transactions, declines, fraud blocks, and chargebacks. Additionally, Stripe provides `PaymentMethod` identifiers (like `pm_card_visa`) for programmatic testing instead of raw card numbers.
WebFetchTool Use
Input
Show input
{
"url": "https://docs.stripe.com/api/payment_intents/create",
"prompt": "What are the required parameters to create a PaymentIntent? Show key fields: amount, currency, payment_method_types, confirm, etc."
}WebFetchTool Use
Input
Show input
{
"url": "https://docs.stripe.com/keys",
"prompt": "Explain Stripe API keys: publishable vs secret, test vs live, how to use them"
}WebFetchTool Result
Result
Show output
# Required Parameters for Creating a PaymentIntent Based on the Stripe API documentation, there are **two required parameters**: ## Mandatory Fields 1. **`amount`** (integer) - "A positive integer representing how much to charge in the smallest currency unit" - Example: 100 cents = $1.00 USD 2. **`currency`** (enum) - "Three-letter ISO currency code, in lowercase. Must be a supported currency" - Example: "usd", "eur", "gbp" ## Optional but Common Parameters - **`confirm`** (boolean) - Set to `true` to immediately confirm the PaymentIntent during creation - **`payment_method`** (string) - Attach an existing payment method - **`customer`** (string) - Associate with a customer ID - **`description`** (string) - Add contextual information about the transaction - **`metadata`** (object) - Store custom key-value pairs for tracking ## Key Note The documentation does **not** list `payment_method_types` as a required parameter for creation. Instead, you can use `automatic_payment_methods.enabled` to accept compatible payment methods, or specify individual methods when confirming.
WebFetchTool Result
Result
Show output
# Stripe API Keys: A Concise Guide ## Publishable vs. Secret Keys **Publishable Keys** (prefix: `pk_test_` or `pk_live_`) These are safe for frontend use in browsers and mobile apps. As stated, they're used to "capture payment information with tools like Stripe Elements or Stripe Checkout" and can be publicly exposed. **Secret Keys** (prefix: `sk_test_` or `sk_live_`) These must remain confidential and only exist on your backend servers. The documentation emphasizes: "anyone who has this key can make API calls through your account." Never share them via email, chat, or unencrypted channels. ## Test vs. Live Mode **Sandbox/Test Mode** (`pk_test_`, `sk_test_`) Designed for development without real financial consequences. Use test credit cards to simulate transactions safely. **Live Mode** (`pk_live_`, `sk_live_`) Processes actual payments from real customers. A critical security note: "You can only reveal a live mode secret key once"—if lost, you must generate a replacement. ## Proper Usage - Store secret keys in encrypted environment variables or vaults, never in source code - Use restricted API keys when possible to limit access to only necessary resources - Implement IP address restrictions for live keys - Rotate keys when team members leave or access is compromised - Switch modes via the dashboard toggle in the developer section
AgentStep 2
Here's what Stripe's own documentation says, organized around your three questions:
---
## What Stripe offers for one-off card payments
Stripe's **Payments** product is exactly this use case. The recommended path is the **PaymentIntents API** — it handles a single charge end-to-end, manages the payment lifecycle (created → processing → succeeded/failed), and handles edge cases like 3D Secure authentication automatically. The docs explicitly note the older Charges API is deprecated; PaymentIntents is the current standard.
---
## Key API concepts you need to understand
**1. API Keys — two types, two modes**
| Key | Prefix | Use |
|-----|--------|-----|
| Secret key | `sk_test_` / `sk_live_` | Server-side only. Never expose publicly. |
| Publishable key | `pk_test_` / `pk_live_` | Safe for frontend (browser/mobile). |
The `test_` variants operate entirely in sandbox mode — no real money moves.
**2. PaymentIntent**
The core object. You create one server-side with two required fields:
```json
{
"amount": 2000, // integer, in smallest currency unit (2000 = $20.00)
"currency": "usd" // ISO 4217 lowercase
}
```
Optional but common: `customer`, `description`, `metadata`, `payment_method`.
**3. Client Secret**
When you create a PaymentIntent, Stripe returns a `client_secret`. Your server passes this to your frontend. The frontend uses it with **Stripe.js** to confirm the payment (collect and tokenize card details). You never handle raw card numbers server-side — Stripe.js handles that.
**4. Payment Methods**
A `PaymentMethod` object represents tokenized card details. In API-only flows (no hosted UI), you create one client-side via Stripe.js, then attach it to the PaymentIntent. Stripe also provides static test IDs like `pm_card_visa` for programmatic testing.
**5. Webhooks**
After payment confirmation, your server listens for webhook events (e.g., `payment_intent.succeeded`, `payment_intent.payment_failed`) to reliably detect the outcome. Don't rely solely on the client-side redirect — webhooks are the authoritative signal.
**6. Payment Element (optional)**
A prebuilt UI component from Stripe.js that renders a card input form. Saves you building card input from scratch and keeps you PCI-compliant since card data never touches your server.
---
## Testing without real money
Yes — fully supported with no setup required beyond using test keys:
- Use your `sk_test_` / `pk_test_` keys (available immediately in the Stripe Dashboard)
- Use test card numbers — no real money is ever charged:
- **Visa success**: `4242 4242 4242 4242`
- Any future expiration date, any 3-digit CVC
- Stripe has cards for simulating declines, fraud blocks, 3DS challenges, etc.
- Stripe also provides a **Sandbox** environment (separate from your live account) accessible via the Dashboard account selector
- For programmatic tests (no card UI), use `pm_card_visa` as a PaymentMethod ID directly in API calls
---
## Minimal flow summary
```
1. Backend: POST /v1/payment_intents → get client_secret
2. Frontend: Stripe.js collects card → confirms PaymentIntent with client_secret
3. Backend: Receive webhook `payment_intent.succeeded` → fulfill order
```
This is the entire model for a one-off charge. You don't need subscriptions, invoices, Connect, or any of Stripe's other products. Task 2
Onboard
OperatorStep 1
Set up a Stripe account so we can start making test API calls. Get to the point where you have a working API key in test mode. Do as much as you can autonomously. If you need me to do something (like verify an email, enter personal details, or complete identity verification), tell me exactly what you need and wait for me to confirm it's done.
ToolSearchTool Use
Input
Show input
{
"query": "select:mcp__claude-in-chrome__tabs_context_mcp"
}ToolSearchTool Result
Result
Show output
[
{
"type": "tool_reference",
"tool_name": "mcp__claude-in-chrome__tabs_context_mcp"
}
]mcp__claude-in-chrome__tabs_context_mcpTool Use
Input
Show input
{
"createIfEmpty": true
}mcp__claude-in-chrome__tabs_context_mcpTool Result
Result
Show output
No Chrome extension connected.
AgentStep 2
The Chrome browser extension isn't connected, so I can't automate the browser directly. I can still walk you through this efficiently — here's what requires you vs. what I can handle once we're past signup. --- ## What you need to do manually (Stripe requires human verification) **Step 1 — Create the account** Go to `https://dashboard.stripe.com/register` and fill in: - Email address - Full name - Country - Password **Step 2 — Verify your email** Stripe will send a confirmation email. Click the link in it. **Step 3 — Skip or defer business details** After email verification, Stripe will ask about your business. You can click **"Skip for now"** or similar — you don't need to complete identity/business verification to get test mode API keys. Test mode is available immediately after email confirmation. --- ## Once you're in the Dashboard Navigate to: **Developers → API keys** (or directly to `https://dashboard.stripe.com/test/apikeys`) You'll see two test mode keys: - **Publishable key** — starts with `pk_test_` - **Secret key** — starts with `sk_test_` (click "Reveal" to show it) Copy the **secret key** — that's what you need for server-side API calls. --- Let me know when you've completed signup and email verification (Step 2), and I'll verify the key works by making a test API call against the Stripe API directly.
OperatorStep 3
Here is the key: sk_test_[REDACTED]
ToolSearchTool Use
Input
Show input
{
"query": "select:Bash"
}ToolSearchTool Result
Result
Show output
[
{
"type": "tool_reference",
"tool_name": "Bash"
}
]BashTool Use
Input
Show input
{
"command": "curl -s https://api.stripe.com/v1/account \\\n -u sk_test_[REDACTED]: \\\n | python3 -m json.tool 2>/dev/null || cat",
"description": "Verify Stripe test API key by fetching account info",
"dangerouslyDisableSandbox": true
}BashTool Result
Result
Show output
{
"id": "acct_1HDZokLSFkr2JHff",
"object": "account",
"business_type": "individual",
"capabilities": {
"bancontact_payments": "active",
"blik_payments": "active",
"card_payments": "active",
"eps_payments": "active",
"giropay_payments": "active",
"ideal_payments": "active",
"klarna_payments": "active",
"link_payments": "active",
"p24_payments": "active",
"sepa_debit_payments": "inactive",
"sofort_payments": "active",
"transfers": "active"
},
"charges_enabled": true,
"country": "DE",
"default_currency": "eur",
"details_submitted": true,
"payouts_enabled": true,
"settings": {
"bacs_debit_payments": {
"display_name": null,
"service_user_number": null
},
"branding": {
"icon": null,
"logo": null,
"primary_color": null,
"secondary_color": null
},
"card_issuing": {
"tos_acceptance": {
"date": null,
"ip": null
}
},
"card_payments": {
"statement_descriptor_prefix": "PMJOBLIST",
"statement_descriptor_prefix_kana": null,
"statement_descriptor_prefix_kanji": null
},
"dashboard": {
"display_name": "PM Job List",
"timezone": "Europe/Berlin"
},
"invoices": {
"default_account_tax_ids": null,
"hosted_payment_method_save": "always"
},
"payments": {
"statement_descriptor": "PMJOBLIST.COM",
"statement_descriptor_kana": null,
"statement_descriptor_kanji": null
},
"payouts": {
"debit_negative_balances": true,
"schedule": {
"delay_days": 7,
"interval": "daily"
},
"statement_descriptor": null
},
"sepa_debit_payments": {}
},
"type": "standard"
}AgentStep 4
The key works. Here's what we can see from the account response: - **Account ID**: `acct_1HDZokLSFkr2JHff` - **Business**: PM Job List (`pmjoblist.com`) - **Country**: Germany (DE), default currency EUR - **`card_payments` capability**: `active` — you can charge cards right now - **`charges_enabled`**: `true` You're fully set up for test mode API calls. --- **One note on security**: you've shared this secret key in the chat. Even though it's a test key with no real money attached, it's good practice to treat it as potentially exposed. When you're ready to go beyond testing, generate a fresh key pair from the Dashboard. For now in test mode it's fine to continue. --- **Quick sanity check — create a test PaymentIntent:**
BashTool Use
Input
Show input
{
"command": "curl -s https://api.stripe.com/v1/payment_intents \\\n -u sk_test_[REDACTED]: \\\n -d amount=2000 \\\n -d currency=eur \\\n -d \"automatic_payment_methods[enabled]=true\" \\\n | python3 -m json.tool",
"description": "Create a test PaymentIntent for €20.00",
"dangerouslyDisableSandbox": true
}BashTool Result
Result
Show output
{
"id": "pi_3TESWgLSFkr2JHff1y7gGR6C",
"object": "payment_intent",
"amount": 2000,
"amount_capturable": 0,
"amount_details": {
"tip": {}
},
"amount_received": 0,
"application": null,
"application_fee_amount": null,
"automatic_payment_methods": {
"allow_redirects": "always",
"enabled": true
},
"canceled_at": null,
"cancellation_reason": null,
"capture_method": "automatic",
"charges": {
"object": "list",
"data": [],
"has_more": false,
"total_count": 0,
"url": "/v1/charges?payment_intent=pi_3TESWgLSFkr2JHff1y7gGR6C"
},
"client_secret": "pi_3TESWgLSFkr2JHff1y7gGR6C_secret_P0DVh9OZr0G7901Oa3DRqfnGR",
"confirmation_method": "automatic",
"created": 1774349374,
"currency": "eur",
"customer": null,
"customer_account": null,
"description": null,
"excluded_payment_method_types": null,
"invoice": null,
"last_payment_error": null,
"latest_charge": null,
"livemode": false,
"metadata": {},
"next_action": null,
"on_behalf_of": null,
"payment_method": null,
"payment_method_configuration_details": {
"id": "pmc_1RcjYTLSFkr2JHffQ9W0GnXz",
"parent": null
},
"payment_method_options": {
"bancontact": {
"preferred_language": "en"
},
"card": {
"installments": null,
"mandate_options": null,
"network": null,
"request_three_d_secure": "automatic"
},
"eps": {},
"giropay": {},
"klarna": {
"preferred_locale": null
},
"link": {
"persistent_token": null
}
},
"payment_method_types": [
"card",
"bancontact",
"eps",
"giropay",
"klarna",
"link"
],
"processing": null,
"receipt_email": null,
"review": null,
"setup_future_usage": null,
"shipping": null,
"source": null,
"statement_descriptor": null,
"statement_descriptor_suffix": null,
"status": "requires_payment_method",
"transfer_data": null,
"transfer_group": null
}AgentStep 5
Everything is working end-to-end. Key things confirmed: - **`livemode: false`** — confirmed test mode, no real money involved - **`status: requires_payment_method`** — PaymentIntent created and waiting for a card (the next step in a real flow) - **`client_secret`** returned — this is what you'd pass to your frontend to collect the card via Stripe.js - **`payment_method_types`** includes `card`, plus several European methods (makes sense for a DE account) You have a working test API key and can create PaymentIntents. You're ready to build.