Pular para o conteúdo principal

Documentation Index

Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt

Use this file to discover all available pages before exploring further.

O SDK Ruby fornece uma maneira simples e intuitiva de integrar Dodo Payments em suas aplicações Ruby. Ele segue as convenções e melhores práticas do Ruby, oferecendo tratamento de erros abrangente, paginação e suporte a middleware.

​
Instalação

Adicione a gem ao seu Gemfile:
Gemfile
gem "dodopayments", "~> 2.9"
Sempre use a versão mais recente do SDK para acessar os recursos mais novos do Dodo Payments. Execute bundle update dodopayments regularmente para manter-se atualizado.
Em seguida, execute: 
bundle install
O SDK é compatível com Ruby 3.2.0 e versões posteriores, com tipos completos, tratamento de erros e mecanismos de retentativa.

​
Início Rápido

Inicialize o cliente e crie uma sessão de checkout: 
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)
Armazene suas chaves de API com segurança usando variáveis de ambiente. Nunca as commitie no controle de versão ou as exponha no código.

​
Recursos Principais

Ruby Conventions

Segue as convenções de nomenclatura do Ruby e padrões idiomáticos

Elegant Syntax

API limpa e legível que parece natural para desenvolvedores Ruby

Auto-Pagination

Iteradores de paginação automática integrados para respostas de listas

Type Safety

Tipos Sorbet opcionais para maior segurança de tipo

​
Configuração

​
Configuração de Timeout

Configure timeouts de requisição: 
# 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: 1}],
  request_options: {timeout: 5}
)

​
Configuração de Repetição

Configure o comportamento de repetição automática: 
# 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: 1}],
  request_options: {max_retries: 5}
)

​
Operações Comuns

​
Criar uma Sessão de Checkout

Gere uma sessão de checkout: 
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

​
Gerenciar Clientes

Crie e recupere informações de clientes: 
# Create a customer
customer = dodo_payments.customers.create(
  email: "customer@example.com",
  name: "John Doe",
  metadata: {
    user_id: "12345"
  }
)

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

​
Gerenciar Assinaturas

Crie e gerencie assinaturas recorrentes: 
# Create a subscription
subscription = dodo_payments.subscriptions.create(
  billing: {
    country: "US",
    city: "San Francisco",
    state: "CA",
    street: "1 Market St",
    zipcode: "94105"
  },
  customer: { customer_id: "cus_123" }, # or { email: "...", name: "..." } for a new customer
  product_id: "pdt_456",
  quantity: 1
)

# Charge an on-demand subscription
# product_price is in the lowest currency denomination (e.g., 2500 = $25.00 USD)
charge = dodo_payments.subscriptions.charge(
  subscription.subscription_id,
  product_price: 2500
)

# Update subscription metadata
updated = dodo_payments.subscriptions.update(
  subscription.subscription_id,
  metadata: { plan_type: "premium" }
)
billing requer no mínimo o código ISO country de duas letras. customer aceita { customer_id: "..." } para anexar um cliente existente ou { email: "...", name: "..." } para criar um novo. product_price está na menor denominação da moeda.

​
Paginação

​
Paginação Automática

Percorre automaticamente todas as páginas: 
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

​
Paginação Manual

Para mais controle sobre a paginação: 
page = dodo_payments.payments.list

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

​
Tratamento de Erros

Trate vários erros da API Dodo Payments: 
begin
  checkout_session = dodo_payments.checkout_sessions.create(
product_cart: [{product_id: "product_id", quantity: 1}]
  )
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
Implemente lógica de repetição com recuo exponencial para erros de limite de taxa para garantir que sua aplicação lide com cenários de alto volume de forma eficiente.

​
Segurança de Tipos com Sorbet

Use Sorbet para parâmetros de requisição de tipos seguros: 
# Type-safe using Sorbet RBI definitions
dodo_payments.checkout_sessions.create(
  product_cart: [
    Dodopayments::ProductItemReq.new(
      product_id: "product_id",
      quantity: 1
    )
  ]
)

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

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

​
Uso Avançado

​
Endpoints Não Documentados

Faça requisições para endpoints não documentados: 
response = dodo_payments.request(
  method: :post,
  path: '/undocumented/endpoint',
  query: {"dog": "woof"},
  headers: {"useful-header": "interesting-value"},
  body: {"hello": "world"}
)

​
Parâmetros Não Documentados

Envie parâmetros não documentados: 
checkout_session_response = dodo_payments.checkout_sessions.create(
  product_cart: [{product_id: "product_id", quantity: 1}],
  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])

​
Integração com Rails

​
Crie um Inicializador

Crie 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"
)

​
Padrão de Objeto de Serviço

Crie um serviço de pagamento: 
# 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

​
Integração com Controlador

Use em seus controladores 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

​
Integração com Sinatra

Use com aplicações 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

​
Recursos

GitHub Repository

Veja o código fonte e contribua

API Reference

Documentação completa da API

Discord Community

Obtenha ajuda e conecte-se com desenvolvedores

Report Issues

Relate bugs ou solicite recursos

​
Suporte

Precisa de ajuda com o Ruby SDK?

​
Contribuição

Aceitamos contribuições! Confira as diretrizes de contribuição para começar.
Last modified on May 14, 2026