Passer au contenu principal
Le SDK Ruby fournit un moyen simple et intuitif d’intégrer Dodo Payments dans vos applications Ruby. Il suit les conventions et les meilleures pratiques de Ruby, offrant une gestion complète des erreurs, de la pagination et un support middleware.

​
Installation

Ajoutez la gem à votre Gemfile :
Gemfile
gem "dodopayments", "~> 1.61.5"
Utilisez toujours la dernière version du SDK pour accéder aux nouvelles fonctionnalités de Dodo Payments. Exécutez bundle update dodopayments régulièrement pour rester à jour.
Puis exécutez : 
bundle install
Le SDK prend en charge Ruby 3.2.0 et les versions ultérieures, avec des types complets, une gestion des erreurs et des mécanismes de réessai.

​
Démarrage rapide

Initialisez le client et créez une session de paiement : 
require "bundler/setup"
require "dodopayments"

dodo_payments = Dodopayments::Client.new(
  bearer_token: ENV["DODO_PAYMENTS_API_KEY"], # This is the default and can be omitted
  environment: "test_mode" # defaults to "live_mode"
)

checkout_session_response = dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 1}]
)

puts(checkout_session_response.session_id)
Conservez vos clés API en toute sécurité en utilisant des variables d’environnement. Ne les engagez jamais dans le contrôle de version ou ne les exposez pas dans votre code.

​
Fonctionnalités principales

Conventions Ruby

Suit les conventions de nommage et les modèles idiomatiques de Ruby

Syntaxe élégante

API propre et lisible qui semble naturelle pour les développeurs Ruby

Auto-Pagination

Itérateurs d’auto-paging intégrés pour les réponses de liste

Sécurité des types

Types Sorbet optionnels pour une sécurité des types améliorée

​
Configuration

​
Configuration du délai d’attente

Configurez les délais d’attente des requêtes : 
# Configure default for all requests (default is 60 seconds)
dodo_payments = Dodopayments::Client.new(
  timeout: nil # disable timeout
)

# Or, configure per-request
dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 0}],
  request_options: {timeout: 5}
)

​
Configuration des réessais

Configurez le comportement de réessai automatique : 
# Configure default for all requests (default is 2)
dodo_payments = Dodopayments::Client.new(
  max_retries: 0 # disable retries
)

# Or, configure per-request
dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 0}],
  request_options: {max_retries: 5}
)

​
Opérations courantes

​
Créer une session de paiement

Générez une session de paiement : 
session = dodo_payments.checkout_sessions.create(
  product_cart: [
    {
      product_id: "prod_123",
      quantity: 1
    }
  ],
  return_url: "https://yourdomain.com/return"
)

# Redirect to checkout
redirect_to session.url

​
Gérer les clients

Créez et récupérez des informations sur les clients : 
# Create a customer
customer = dodo_payments.customers.create(
  email: "[email protected]",
  name: "John Doe",
  metadata: {
    user_id: "12345"
  }
)

# Retrieve customer
customer = dodo_payments.customers.retrieve("cus_123")
puts "Customer: #{customer.name} (#{customer.email})"

​
Gérer les abonnements

Créez et gérez des abonnements récurrents : 
# Create a subscription
subscription = dodo_payments.subscriptions.create(
  customer_id: "cus_123",
  product_id: "prod_456",
  price_id: "price_789"
)

# Update subscription
updated = dodo_payments.subscriptions.update(
  subscription.id,
  metadata: { plan_type: "premium" }
)

# Cancel subscription
dodo_payments.subscriptions.cancel(subscription.id)

​
Pagination

​
Auto-Pagination

Itérez automatiquement à travers toutes les pages : 
page = dodo_payments.payments.list

# Fetch single item from page
payment = page.items[0]
puts(payment.brand_id)

# Automatically fetches more pages as needed
page.auto_paging_each do |payment|
  puts(payment.brand_id)
end

​
Pagination manuelle

Pour plus de contrôle sur la pagination : 
page = dodo_payments.payments.list

if page.next_page?
  new_page = page.next_page
  puts(new_page.items[0].brand_id)
end

​
Gestion des erreurs

Gérez diverses erreurs de l’API Dodo Payments : 
begin
  checkout_session = dodo_payments.checkout_sessions.create(
    product_cart: [{product_id: "product_id", quantity: 0}]
  )
rescue Dodopayments::Errors::APIConnectionError => e
  puts("The server could not be reached")
  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
rescue Dodopayments::Errors::RateLimitError => e
  puts("A 429 status code was received; we should back off a bit.")
rescue Dodopayments::Errors::APIStatusError => e
  puts("Another non-200-range status code was received")
  puts(e.status)
end
Implémentez une logique de réessai avec un backoff exponentiel pour les erreurs de limite de taux afin de garantir que votre application gère les scénarios à fort volume de manière fluide.

​
Sécurité des types avec Sorbet

Utilisez Sorbet pour des paramètres de requête sûrs en termes de types : 
# Type-safe using Sorbet RBI definitions
dodo_payments.checkout_sessions.create(
  product_cart: [
    Dodopayments::CheckoutSessionRequest::ProductCart.new(
      product_id: "product_id",
      quantity: 0
    )
  ]
)

# Hashes work, but are not typesafe
dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 0}]
)

# You can also splat a full Params class
params = Dodopayments::CheckoutSessionCreateParams.new(
  product_cart: [
    Dodopayments::CheckoutSessionRequest::ProductCart.new(
      product_id: "product_id",
      quantity: 0
    )
  ]
)
dodo_payments.checkout_sessions.create(**params)

​
Utilisation avancée

​
Points de terminaison non documentés

Faites des requêtes vers des points de terminaison non documentés : 
response = dodo_payments.request(
  method: :post,
  path: '/undocumented/endpoint',
  query: {"dog": "woof"},
  headers: {"useful-header": "interesting-value"},
  body: {"hello": "world"}
)

​
Paramètres non documentés

Envoyez des paramètres non documentés : 
checkout_session_response = dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 0}],
  request_options: {
    extra_query: {my_query_parameter: value},
    extra_body: {my_body_parameter: value},
    extra_headers: {"my-header": value}
  }
)

# Access undocumented response properties
puts(checkout_session_response[:my_undocumented_property])

​
Intégration Rails

​
Créer un initialiseur

Créez config/initializers/dodo_payments.rb : 
require "dodopayments"

DODO_CLIENT = Dodopayments::Client.new(
  bearer_token: Rails.application.credentials.dodo_api_key,
  environment: Rails.env.production? ? "live_mode" : "test_mode"
)

​
Modèle d’objet de service

Créez un service de paiement : 
# app/services/payment_service.rb
class PaymentService
  def initialize
    @client = DODO_CLIENT
  end

  def create_checkout(items)
    @client.checkout_sessions.create(
      product_cart: items,
      return_url: Rails.application.routes.url_helpers.checkout_return_url
    )
  end

  def process_payment(amount:, currency:, customer_id:)
    @client.payments.create(
      amount: amount,
      currency: currency,
      customer_id: customer_id
    )
  end
end

​
Intégration du contrôleur

Utilisez dans vos contrôleurs Rails : 
# app/controllers/checkouts_controller.rb
class CheckoutsController < ApplicationController
  def create
    service = PaymentService.new
    session = service.create_checkout(checkout_params[:items])
    
    redirect_to session.url, allow_other_host: true
  rescue Dodopayments::Errors::APIError => e
    flash[:error] = "Payment error: #{e.message}"
    redirect_to cart_path
  end

  private

  def checkout_params
    params.require(:checkout).permit(items: [:product_id, :quantity])
  end
end

​
Intégration Sinatra

Utilisez avec des applications Sinatra : 
require "sinatra"
require "dodopayments"

configure do
  set :dodo_client, Dodopayments::Client.new(
    bearer_token: ENV["DODO_API_KEY"]
  )
end

post "/create-checkout" do
  content_type :json
  
  begin
    session = settings.dodo_client.checkout_sessions.create(
      product_cart: JSON.parse(request.body.read)["items"],
      return_url: "#{request.base_url}/return"
    )
    
    { checkout_url: session.url }.to_json
  rescue Dodopayments::Errors::APIError => e
    status 400
    { error: e.message }.to_json
  end
end

​
Ressources

Dépôt GitHub

Voir le code source et contribuer

Référence API

Documentation API complète

Communauté Discord

Obtenez de l’aide et connectez-vous avec des développeurs

Signaler des problèmes

Signalez des bugs ou demandez des fonctionnalités

​
Support

Besoin d’aide avec le SDK Ruby ?

​
Contribuer

Nous accueillons les contributions ! Consultez les directives de contribution pour commencer.