Best use case
Stripe Testing is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
## Overview
Teams using Stripe Testing should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/stripe-testing/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How Stripe Testing Compares
| Feature / Agent | Stripe Testing | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
## Overview
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Stripe Testing ## Overview This skill helps you test and debug Stripe payment integrations end-to-end. It covers webhook verification, payment flow simulation using Stripe CLI and test mode, charge failure diagnosis, and subscription lifecycle validation. ## Instructions ### Setting Up the Test Environment 1. Verify Stripe CLI is installed: `stripe --version` 2. Check for a test API key in environment variables (`STRIPE_SECRET_KEY` starting with `sk_test_`) 3. If no key is found, instruct the user to set one from the Stripe Dashboard → Developers → API keys 4. Run `stripe listen --forward-to localhost:<port>/webhooks/stripe` to forward webhooks locally ### Debugging Failed Charges 1. Ask for the payment intent ID or charge ID (starts with `pi_` or `ch_`) 2. Retrieve details: `stripe payment_intents retrieve <id> --api-key $STRIPE_SECRET_KEY` 3. Check the `last_payment_error` field for the decline reason 4. Common decline codes and fixes: - `card_declined` → Use test card `4000000000000002` to reproduce - `insufficient_funds` → Test with `4000000000009995` - `expired_card` → Test with `4000000000000069` - `incorrect_cvc` → Test with `4000000000000127` 5. Check the Events tab: `stripe events list --limit 5 --api-key $STRIPE_SECRET_KEY` ### Testing Webhook Handlers 1. List registered webhook endpoints: `stripe webhook_endpoints list --api-key $STRIPE_SECRET_KEY` 2. Trigger a specific event: `stripe trigger <event_type>` (e.g., `stripe trigger payment_intent.succeeded`) 3. Verify the local server received and processed the event correctly 4. Check webhook signature verification in the handler code — look for `stripe.webhooks.constructEvent()` 5. Common webhook events to test: - `checkout.session.completed` - `invoice.payment_succeeded` - `invoice.payment_failed` - `customer.subscription.updated` - `customer.subscription.deleted` ### Validating Subscription Lifecycle 1. Create a test customer: `stripe customers create --name "Test User" --email test@example.com --api-key $STRIPE_SECRET_KEY` 2. Create a subscription with a test clock for time simulation: ``` stripe test_clocks create --frozen-time $(date +%s) --api-key $STRIPE_SECRET_KEY ``` 3. Advance the test clock to simulate billing cycles: ``` stripe test_clocks advance <clock_id> --frozen-time <future_timestamp> --api-key $STRIPE_SECRET_KEY ``` 4. Verify subscription status transitions: `trialing` → `active` → `past_due` → `canceled` ### Reading Server-Side Logs 1. Search the application logs for Stripe-related entries (look for `stripe`, `webhook`, `payment`) 2. Check for HTTP 4xx/5xx responses to Stripe webhook deliveries 3. Verify idempotency — duplicate webhook deliveries should not create duplicate records ## Examples ### Example 1: Debug a Failed Checkout **User prompt:** ``` Our checkout is failing for some customers. The last failed payment intent is pi_3OxR2aKX8dVqS71m0abc1234. Can you figure out what's going wrong? ``` **Agent actions:** ```bash stripe payment_intents retrieve pi_3OxR2aKX8dVqS71m0abc1234 --api-key $STRIPE_SECRET_KEY ``` **Agent output:** ``` Payment Intent pi_3OxR2aKX8dVqS71m0abc1234: Status: requires_payment_method Last error: card_declined (generic_decline) Amount: $49.00 USD Customer: cus_PqR7xYz Analysis: 1. The card was declined with a generic decline — this means the issuing bank refused it 2. This is NOT a code issue — the customer's bank rejected the charge 3. Your error handling looks correct — the PI moved to requires_payment_method Recommendations: - Ensure your frontend shows a clear "card declined" message - Offer alternative payment methods (Apple Pay, Google Pay, bank transfer) - Check if you have retry logic for `invoice.payment_failed` webhooks ``` ### Example 2: Verify Webhook Handler Works **User prompt:** ``` I just deployed a new webhook handler for subscription cancellations. Can you test it? ``` **Agent actions:** ```bash stripe listen --forward-to localhost:3000/api/webhooks/stripe & stripe trigger customer.subscription.deleted ``` **Agent output:** ``` Webhook forwarding active on localhost:3000/api/webhooks/stripe Triggered: customer.subscription.deleted → Delivered to localhost:3000/api/webhooks/stripe [200 OK] in 145ms Verified: ✓ Webhook received and acknowledged with 200 ✓ Signature verification passed (using whsec_ signing secret) ✓ Event type correctly matched to handler Next steps: - Check your database: was the subscription marked as canceled? - Verify the customer received a cancellation email - Test edge case: trigger it twice to confirm idempotency ``` ## Guidelines - Always use test mode keys (`sk_test_`) — never use live keys for testing - Use Stripe's built-in test card numbers rather than real card data - Test clocks are essential for subscription testing — they let you fast-forward time - Always verify webhook signature validation is implemented correctly - Check for race conditions: webhooks can arrive before the redirect completes - Monitor the Stripe Dashboard → Developers → Webhooks for delivery failures - Use `--api-key` flag explicitly rather than relying on environment to avoid mistakes
Related Skills
performing-visual-regression-testing
This skill enables Claude to execute visual regression tests using tools like Percy, Chromatic, and BackstopJS. It captures screenshots, compares them against baselines, and analyzes visual differences to identify unintended UI changes. Use this skill when the user requests visual testing, UI change verification, or regression testing for a web application or component. Trigger phrases include "visual test," "UI regression," "check visual changes," or "/visual-test".
performing-security-testing
This skill automates security vulnerability testing. It is triggered when the user requests security assessments, penetration tests, or vulnerability scans. The skill covers OWASP Top 10 vulnerabilities, SQL injection, XSS, CSRF, authentication issues, and authorization flaws. Use this skill when the user mentions "security test", "vulnerability scan", "OWASP", "SQL injection", "XSS", "CSRF", "authentication", or "authorization" in the context of application or API testing.
performance-testing
This skill enables Claude to design, execute, and analyze performance tests using the performance-test-suite plugin. It is activated when the user requests load testing, stress testing, spike testing, or endurance testing, and when discussing performance metrics such as response time, throughput, and error rates. It identifies performance bottlenecks related to CPU, memory, database, or network issues. The plugin provides comprehensive reporting, including percentiles, graphs, and recommendations.
performing-penetration-testing
This skill enables automated penetration testing of web applications. It uses the penetration-tester plugin to identify vulnerabilities, including OWASP Top 10 threats, and suggests exploitation techniques. Use this skill when the user requests a "penetration test", "pentest", "vulnerability assessment", or asks to "exploit" a web application. It provides comprehensive reporting on identified security flaws.
automating-mobile-app-testing
This skill enables automated testing of mobile applications on iOS and Android platforms using frameworks like Appium, Detox, XCUITest, and Espresso. It generates end-to-end tests, sets up page object models, and handles platform-specific elements. Use this skill when the user requests mobile app testing, test automation for iOS or Android, or needs assistance with setting up device farms and simulators. The skill is triggered by terms like "mobile testing", "appium", "detox", "xcuitest", "espresso", "android test", "ios test".
load-testing-apis
Execute comprehensive load and stress testing to validate API performance and scalability. Use when validating API performance under load. Trigger with phrases like "load test the API", "stress test API", or "benchmark API performance".
testing-load-balancers
This skill enables Claude to test load balancing strategies. It validates traffic distribution across backend servers, tests failover scenarios when servers become unavailable, verifies sticky sessions, and assesses health check functionality. Use this skill when the user asks to "test load balancer", "validate traffic distribution", "test failover", "verify sticky sessions", or "test health checks". It is specifically designed for testing load balancing configurations using the `load-balancer-tester` plugin.
managing-database-testing
This skill manages database testing by generating test data, wrapping tests in transactions, and validating database schemas. It is used to create robust and reliable database interactions. Claude uses this skill when the user requests database testing utilities, including test data generation, transaction management, schema validation, or migration testing. Trigger this skill by mentioning "database testing," "test data factories," "transaction rollback," "schema validation," or using the `/db-test` or `/dbt` commands.
backtesting-trading-strategies
Backtest crypto and traditional trading strategies against historical data. Calculates performance metrics (Sharpe, Sortino, max drawdown), generates equity curves, and optimizes strategy parameters. Use when user wants to test a trading strategy, validate signals, or compare approaches. Trigger with phrases like "backtest strategy", "test trading strategy", "historical performance", "simulate trades", "optimize parameters", or "validate signals".
api-testing-helper
Api Testing Helper - Auto-activating skill for API Development. Triggers on: api testing helper, api testing helper Part of the API Development skill category.
automating-api-testing
This skill automates API endpoint testing, including request generation, validation, and comprehensive test coverage for REST and GraphQL APIs. It is used when the user requests API testing, contract testing, or validation against OpenAPI specifications. The skill analyzes API endpoints and generates test suites covering CRUD operations, authentication flows, and security aspects. It also validates response status codes, headers, and body structure. Use this skill when the user mentions "API testing", "REST API tests", "GraphQL API tests", "contract tests", or "OpenAPI validation".
planning-oracle-to-postgres-migration-integration-testing
Creates an integration testing plan for .NET data access artifacts during Oracle-to-PostgreSQL database migrations. Analyzes a single project to identify repositories, DAOs, and service layers that interact with the database, then produces a structured testing plan. Use when planning integration test coverage for a migrated project, identifying which data access methods need tests, or preparing for Oracle-to-PostgreSQL migration validation.