How can I dynamically switch between live and test Stripe credentials using the pay gem in Rails?

Answer

There isn’t a built-in way in pay gem v2.2.2 to dynamically switch between live and test credentials at runtime in production. The gem is designed to fetch Stripe keys based on the Rails environment (e.g. using Rails.application.credentials.production for production), so even if you have both test and live keys configured in your credentials, the gem determines which one to use based solely on Rails.env.

The only current workaround is to override the gem’s env method in an initializer. However, as you found, this approach is global—it forces a single mode (test or live) across the entire application rather than per user request. In other words, without modifying the gem’s internals or providing your own wrapper, you cannot conditionally switch modes on a per-request basis in production.

Potential Approaches

If you need to support both modes simultaneously, you might consider one of the following options:

1. Custom Wrapper Module
   Instead of relying on the pay gem’s automatic credential fetching, you could write a custom wrapper around your payment processing logic. In that wrapper, use your own logic (for example, checking a user preference stored in the session or a parameter on the request) to choose between test and live API keys when initializing the Stripe client.

   Example sketch:

   RUBYCopied
   module PaymentProcessor
     def self.stripe_client(user_mode: :live)
       # Assuming you have stored your credentials in a separate config store
       credentials = case user_mode
       when :test
         Rails.application.credentials.test[:stripe]
       else
         Rails.application.credentials.production[:stripe]
       end
   
       Stripe.api_key = credentials[:secret_key]
       # Optionally, export the public key if needed
       credentials
     end
   
     def self.charge(amount, currency, source, opts = {})
       # Example method that chooses the client based on some runtime flag
       user_mode = opts[:user_mode] || :live
       stripe_client(user_mode: user_mode)
       Stripe::Charge.create({
         amount: amount,
         currency: currency,
         source: source,
         description: opts[:description]
       })
     end
   end

   In whatever part of your application calls payment processing, you would specify the desired mode.

2. Monkey Patching (Advanced and Not Recommended)
   You could attempt to override the pay gem’s internal method that determines the environment on a per-request basis. This would likely require a monkey patch that reads from the current request or session to decide the environment, but it comes with maintainability and support risks. Since pay does not currently support that, you’d need to be very cautious with upgrades.

Conclusion

Due to the way the pay gem is designed, dynamic switching between live and test modes in production isn’t supported out-of-the-box. The recommended approach is to handle the dynamic key selection in your own payment processing layer rather than relying solely on the initializer override provided by pay gem. This way you can respect the user's preference at runtime without compromising global configuration.