James Beswick

Learn effective data reconciliation strategies to keep product information synchronized between your internal systems and Stripe. Explore real-time vs batch processing tools, validation techniques, and best practices for maintaining consistent data across multiple platforms as your business scales.

Real-time vs batch reconciliation: Practical patterns for keeping data in sync

Learn advanced database reconciliation patterns for Stripe integration. Explore queue-based architectures, event-driven sync, and robust error handling to maintain product data consistency at scale.

From naive webhooks to durable sync: Queue-based and event-driven data reconciliation patterns

Learn how product data synchronization between internal databases and payment providers like Stripe evolves from simple scripts to complex architectural challenges as your business scales from hundreds to millions of products.

Keeping product data aligned with Stripe as your systems scale

Discover the latest from Stripe Sessions! Explore new products, APIs, and enhancements, including Stripe Workflows for no-code automation, MCP server for AI integration, and Accounts v2 for streamlined management.

Sessions 2025 Developer Track resources

Discover advanced caching strategies to optimize Stripe API performance in AWS Lambda using Amazon ElastiCache and DynamoDB. Learn how to manage API rate limits, reduce latency, and minimize costs while ensuring data consistency and scalability in high-volume applications.

Optimizing Stripe API performance in Lambda with caching strategies

Explore the complexities of enterprise subscription management and discover how an AWS microservice architecture can streamline subscription lifecycles. This guide uses AWS services to create a scalable, reliable, and auditable subscription management system, addressing challenges like mid-cycle plan changes and usage-based billing adjustments.

Using an AWS microservice architecture for subscription management

Discover how to build a scalable real-time payment analytics pipeline from Stripe to AWS. This guide explores the challenges, architectural components, and implementation details to help businesses monitor transactions, enhance security, and gain insights into customer behavior.

Real-time payment analytics: Building a data pipeline from Stripe to AWS

Implementing a resilient multi-region payment processing system using AWS and Stripe ensures reliable webhook handling, minimizes outages, and complies with regulations. This guide covers architecture design, challenges, and AWS service integration for optimal global performance and rate limit management.

Load balancing Stripe API calls from multiple AWS regions

Learn how to securely manage and automatically rotate your Stripe API keys in AWS for a production-grade approach. This guide covers best practices, tools, and strategies to enhance the security of your financial transactions.

Securing Stripe API Keys in AWS with automatic rotation

Learn about Stripe integrations with essential tips for robust, secure payment systems and seamless user experiences. This guide prepares developers for real-world scenarios, from subscription management to dispute resolution, ensuring secure and seamless payments.

Building rock-solid Stripe integrations: A developer's guide to success

Discover how to build reliable webhook handlers for Stripe events using AWS in this comprehensive guide. Learn about the challenges of processing webhook events at scale and how to address them with an enterprise-grade architecture.

Building resilient webhook handlers in AWS: Implementing DLQs for Stripe events

Discover the key concepts and terms for integrating Stripe in your applications. This guide covers Payment Intents Customer management, Subscription billing, Webhooks, Disputes, Refunds, and the benefits of expanded responses, providing developers with the tools they need to streamline payment processing efficiently.

New to Stripe? Learn the key concepts for software developers.

Stripe sandboxes enhance test environment management, offering improved functionality over test mode, allowing isolated accounts, multiple developers, and better access control while integrating seamlessly with AWS applications.

Managing multiple Stripe test environments from your AWS-hosted application

This blog shows how to find when something is wrong in production, avoid jumping between tabs/docs to find information, and resolving issues quickly in the troubleshooting process, using an AWS integration as a starting point.

Resolving production issues in your AWS/Stripe integration using Workbench

For developers building on AWS, you have various choices for processing payments within your application. Most developers choose a payment processing service to handle this part of their application flow, which involves integrating with a third-party vendor outside of the AWS environment.

Debugging your AWS/Stripe integration just got easier

Subscribe to Stripe Developers on YouTube.

Follow us at @Stripedev on twitter for updates and answers to your developer questions.

Check out the docs for the in-depth developer guidance.

Join the Stripe Discord server to chat live with other developers.

Join a local Stripe Developer Meetup to learn about the latest features and network with your community.



Many Stripe customers use AWS to host their applications and use CI/CD tools to manage and deploy changes to their production and test environments. Stripe has always provided a [test mode](https://docs.stripe.com/test-mode) for testing integrations but for complex applications additional capabilities may be needed.

With the new [Stripe sandboxes](https://docs.stripe.com/sandboxes) feature, developers can manage multiple test environments from a single Stripe account. It provides richer functionality than test mode and enables you to map test environments more easily to multiple developers in your AWS accounts. With Sandboxes, you can simulate external events to test payments, accumulating a fake balance instead of real transactions, and use the Test Payouts functionality using API v2 keys, calling API v2. You can use the CLI or SDK to interact with sandboxes by simply changing the API keys used.  

This blog post shows how to use demo data in Stripe sandboxes for AWS-hosted applications and how to store the resulting API key securely for use in CI workflows.

## **Seeding sandboxes with test data locally**

Using the [Stripe API](https://docs.stripe.com/api), you can create test data for customers, products, prices, and other Stripe objects that can help test the accuracy of your Stripe integration.

To import a custom set of data for your sandbox, you can optionally export data from other sandboxes or production accounts, or create test data from a script. This section focuses on [Product](https://docs.stripe.com/api/products) data but the same process applies to other objects, such as [Customers](https://docs.stripe.com/api/customers/object).

To export product data from a production account:

1. Navigate to the **Product catalog** tab in the [Stripe dashboard](https://dashboard.stripe.com/) for the production account.   
2. Choose **Export products** to open the export configuration dialog:

![](/images/using-demo-data-for-testing-stripe-integrations-in-aws/image1.png)

3. Under *Date range*, choose **All** to include all products configured in the account, then choose **Export**. This creates a CSV file containing all your products.

![](/images/using-demo-data-for-testing-stripe-integrations-in-aws/image3.png)

4. To import this data into a Sandbox, you can [iterate through the CSV file](https://github.com/stephanie56/stripe-batch-subscribe/blob/master/createCustomers.js) and use the SDK to [create each product](https://docs.stripe.com/api/products/create).

If you only want to use test data, you can build a test script to run from your local development machine. To build this script:

1. Run stripe login in your terminal and [log into](https://docs.stripe.com/cli/login) your preferred sandbox account. Any subsequent CLI commands will be run against this account.  
2. In your text editor, create a new file with the name `create-test-data.sh`.  
3. Ensure you update the file’s permissions in your terminal. In macOS or Linux, run `chmod 755 create-test-data.sh`.  
4. To create products, add the following line per product, replacing the attributes with your product’s value:  
`stripe products create \--name "Your product name" \--description “Your description”`
5. Run the script from the terminal: `./create-test-data.sh`

![](/images/using-demo-data-for-testing-stripe-integrations-in-aws/image2.png)

## **Creating test data from CI processes and automation tools**

You can also use this script in your [GitHub Actions](https://docs.github.com/en/actions) or [continuous integration](https://aws.amazon.com/devops/continuous-integration/#:~:text=Continuous%20integration%20is%20a%20DevOps,builds%20and%20tests%20are%20run.) tools to populate sandboxes. However, you must update it to ensure the [script has a valid API key to run against the appropriate sandbox](https://www.google.com/url?q=https://docs.google.com/document/d/1ESNC_iD7ndrxhzlSgN5nFAHqRJl0ElpfZXzlfWKJjlQ/&sa=D&source=docs&ust=1724777703563355&usg=AOvVaw1eZbHDJ3nTKkSMF30S-rmZ). Since the interactive mode of stripe login requires input in a terminal, the easier way is to pass the API key into each CLI action:

```bash
stripe products create --name "Your product name" --description “Your description” --api-key "sk_test_YOUR_KEY"
```

Although you can use an API key as a variable, it’s recommended that you store this information securely, and access it via an environment variable. You should not use the following example, or commit this code to source control, to avoid potentially leaking API keys later:

![](/images/using-demo-data-for-testing-stripe-integrations-in-aws/image5.png)

*Read more about [Best Practices for Key Management](https://docs.stripe.com/keys-best-practices)..* 

From AWS-hosted applications, you can store the sandbox API key in [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/) to retrieve the key dynamically at runtime and don’t log the key from code. Secrets Manager allows you to securely store and rotate secrets and use [AWS Identity & Access Management](https://docs.aws.amazon.com/iam/) to limit access. You can enable read or write access per IAM user or IAM role or principal, and grant access over multiple AWS accounts if you using accounts to manage different environments.

You can use the [AWS CLI](https://aws.amazon.com/cli/) to access the secret via the script. You can also use the [AWS SDK](https://aws.amazon.com/developer/tools/) to access the secret directly from code, if you are using services like AWS Lambda or AWS Fargate.

In the CLI, for Linux or macOS, you can use the following command to extract a secret and then use the `SECRET_KEY` variable in your script:

```bash
SECRET_ARN=arn:aws:secretsmanager:us-east-1:abcd123:secret:/example
SECRET_KEY=STRIPE_SANDBOX_API_KEY
aws secretsmanager get-secret-value  --secret-id $SECRET_ARN  --query SecretString --output text | grep -o '"$SECRET_KEY":"[^"]*' |  grep -o '[^"]*$'
```

Similarly, PowerShell developers can use the following to extract the secret via the Secrets Manager CLI:

```PowerShell
$secret_key = aws secretsmanager get-secret-value --region <region> --secret-id <secret-name> | ConvertFrom-Json
```

Once your test scripts finish running, you may optionally run a script that uses the [product delete API](https://docs.stripe.com/api/products/delete) to remove these from your sandbox. 

While a sandbox will never have access to production and cannot be used to move real money, it’s recommended that you treat API keys for these the same way as you do for production. Specifically:

* Don’t embed API keys in code, or pass keys around in chat, email, or other unsecure means. Use services like [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/) to retrieve the key dynamically at runtime without logging  the key in your code.  
* Don’t store keys in source repositories like [GitHub](https://github.com/), even if the repo is private since this can result in key leakage later.  
* Rotate your keys periodically in the Stripe dashboard, and then update AWS Secrets Manager. Restrict who has access to create, modify or delete keys in both Stripe and AWS.

## **Conclusion**

Stripe’s new sandbox feature makes it easier to create an isolated testing environment loaded with test data. You can use the built-in templates to automatically populate a sandbox with data. Alternatively, for more control, you can export your production data and import into a sandbox, or create test data using the CLI via scripting.

This post shows how you store your API keys securely using AWS Secrets Manager for your AWS-hosted applications. Your CI scripts can then access those secrets at runtime, store the secret in an environment variable, and pass this into the Stripe CLI with each request. This helps create test scripts that handle secrets securely and you can commit to code repos without leaking API keys.

To learn more about developing applications with Stripe, visit our [YouTube Channel](https://www.youtube.com/stripedevelopers).

![](/images/using-demo-data-for-testing-stripe-integrations-in-aws/image4.png)

This post discusses integrating the Stripe agent toolkit with large language models (LLMs) to enhance automation workflows, enabling financial services access, metered billing, and streamlined operations across agent frameworks.

Using demo data for testing Stripe integrations in AWS-hosted applications

James Beswick