ruby

Is Integrating Stripe with Ruby on Rails Really This Simple?

Stripe Meets Ruby on Rails: A Simplified Symphony of Seamless Payment Integration

Is Integrating Stripe with Ruby on Rails Really This Simple?

When it comes to integrating Stripe into a Ruby on Rails application, it’s way simpler than you might think. Here’s an easy-to-follow guide to get you set up without any hassle.

First up, you need to get your hands on those API keys, which means creating a developer profile on Stripe. Once you’re logged into Stripe, head over to the Account Settings and locate the API keys section. You’ll find your test and live secret keys, along with your publishable keys there. Using test keys during development is super important so you don’t accidentally charge any real customers.

Now, it’s time to add the Stripe gem into your Rails application. Open up your Gemfile and punch in the following line:

gem 'stripe'

After that, just run the bundle command in your terminal to get the gem installed. Easy peasy.

Next, you gotta set up your API keys in the application. Create a secrets.yml file in your config directory and add your test and live keys:

development:
  stripe_secret_key: 'sk_test_your_test_secret_key'
  stripe_publishable_key: 'pk_test_your_test_publishable_key'

production:
  stripe_secret_key: 'sk_live_your_live_secret_key'
  stripe_publishable_key: 'pk_live_your_live_publishable_key'

Make sure to replace the placeholder keys with your actual keys from the Stripe dashboard.

You’ll also need to get your Stripe configuration sorted. Create a new file in config/initializers named stripe.rb and toss in:

Stripe.api_key = Rails.application.secrets.stripe_secret_key

This is just setting your Stripe API key based on your environment.

To accept payments, you need a payment form. You can use Stripe’s pre-built Checkout form, or you can go for a custom form if that better fits your needs. Here’s an example of a very simple custom form:

<%= form_tag charges_path, id: "payment-form" do %>
  <script src="https://js.stripe.com/v3/"></script>
  <div id="card-element"></div>
  <button id="submit">Submit Payment</button>
  <div id="card-errors" role="alert"></div>

  <script>
    const stripe = Stripe('<%= Rails.application.secrets.stripe_publishable_key %>');
    const elements = stripe.elements();

    const card = elements.create('card', { hidePostalCode: true });
    card.mount('#card-element');

    const form = document.getElementById('payment-form');
    form.addEventListener('submit', async (event) => {
      event.preventDefault();
      const { token, error } = await stripe.createToken(card);
      if (error) {
        document.getElementById('card-errors').textContent = error.message;
      } else {
        const hiddenInput = document.createElement('input');
        hiddenInput.setAttribute('type', 'hidden');
        hiddenInput.setAttribute('name', 'stripeToken');
        hiddenInput.setAttribute('value', token.id);
        form.appendChild(hiddenInput);
        form.submit();
      }
    });
  </script>
<% end %>

This form uses Stripe.js to securely handle the credit card info and create a token that you can send to your server.

On the server side, to process the payment, you’ll need a controller action to handle that Stripe token. Here’s a starter example:

class ChargesController < ApplicationController
  def create
    @amount = 500 # Amount in cents

    customer = Stripe::Customer.create(
      email: params[:stripeEmail],
      source: params[:stripeToken]
    )

    charge = Stripe::Charge.create(
      customer: customer.id,
      amount: @amount,
      description: 'Rails Stripe customer',
      currency: 'usd'
    )

  rescue Stripe::CardError => e
    flash[:error] = e.message
    redirect_to new_charge_path
  end
end

This bit of code creates a new customer and charges their card with the given token.

Stripe also makes it super easy to handle recurring subscriptions. For this, you’ll need to create a subscription model and manage creation and updates. Here’s a basic example to get you rolling:

class SubscriptionsController < ApplicationController
  def create
    @plan = 'monthly' 

    customer = Stripe::Customer.create(
      email: params[:stripeEmail],
      source: params[:stripeToken]
    )

    subscription = Stripe::Subscription.create(
      customer: customer.id,
      items: [{ plan: @plan }],
      expand: ['latest_invoice.payment_intent']
    )

  rescue Stripe::CardError => e
    flash[:error] = e.message
    redirect_to new_subscription_path
  end
end

This creates a new customer and subscribes them to a specific plan.

Now, let’s talk about handling webhooks. Webhooks let Stripe notify you about events happening in your Stripe account. To handle them, you need an endpoint in your app. An example endpoint set up to receive and verify webhooks looks like this:

class WebhooksController < ApplicationController
  skip_before_action :verify_authenticity_token

  def create
    payload = request.body.read
    sig_header = request.env['HTTP_STRIPE_SIGNATURE']
    endpoint_secret = Rails.application.secrets.stripe_webhook_secret

    begin
      event = Stripe::Webhook.construct_event(payload, sig_header, endpoint_secret)
      # Handle the event
      case event.type
      when 'invoice.payment_succeeded'
        # Handle successful payment
      when 'invoice.payment_failed'
        # Handle failed payment
      end
    rescue JSON::ParserError => e
      # Invalid payload
      render json: { error: 'Invalid payload' }, status: 400
    rescue Stripe::SignatureVerificationError => e
      # Invalid signature
      render json: { error: 'Invalid signature' }, status: 400
    end

    render json: { received: true }
  end
end

This code snippet verifies the webhook signature and processes the event accordingly.

To wrap it all up, integrating Stripe into a Ruby on Rails application is an amazing way to streamline transactions and subscriptions. By following these steps, you can securely handle payments, manage subscriptions, and get notifications directly with webhooks. Always use test keys during development and keep your secret keys safe—don’t let them get into source control. With Stripe, you’ve got the tools to build a rock-solid payment solution that scales with your business needs.

Keywords: Stripe API keys, integrate Stripe Rails, Stripe gem Rails, Stripe payment form, Rails Stripe setup, Stripe subscription Rails, Stripe webhooks Rails, Ruby on Rails Stripe, Stripe payments integration, Stripe configuration Rails



Similar Posts
Blog Image
8 Advanced OAuth 2.0 Techniques for Ruby on Rails: Boost Security and Efficiency

Discover 8 advanced OAuth 2.0 techniques for Ruby on Rails. Learn secure token management, multi-provider integration, and API authentication. Enhance your app's security today!

Blog Image
10 Proven Ruby on Rails Performance Optimization Techniques for High-Traffic Websites

Boost your Ruby on Rails website performance with 10 expert optimization techniques. Learn how to handle high traffic efficiently and improve user experience. #RubyOnRails #WebPerformance

Blog Image
Mastering Rust's Procedural Macros: Boost Your Code with Custom Syntax

Dive into Rust's procedural macros: Powerful code generation tools for custom syntax, automated tasks, and language extension. Boost productivity and write cleaner code.

Blog Image
Is Your Rails App Lagging? Meet Scout APM, Your New Best Friend

Making Your Rails App Lightning-Fast with Scout APM's Wizardry

Blog Image
Is Ruby Hiding Its Methods? Unravel the Secrets with a Treasure Hunt!

Navigating Ruby's Method Lookup: Discovering Hidden Paths in Your Code

Blog Image
Is Your Ruby Code Missing Out on the Hidden Power of Fibers?

Unlock Ruby's Full Async Potential Using Fibers for Unmatched Efficiency