Langsung ke konten utama

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.

SDK Ruby menyediakan cara yang sederhana dan intuitif untuk mengintegrasikan Dodo Payments ke dalam aplikasi Ruby Anda. Ini mengikuti konvensi dan praktik terbaik Ruby, menawarkan penanganan kesalahan yang komprehensif, paginasi, dan dukungan middleware.

​
Instalasi

Tambahkan gem ke dalam Gemfile Anda:
Gemfile
gem "dodopayments", "~> 2.9"
Selalu gunakan versi SDK terbaru untuk mengakses fitur Dodo Payments yang paling mutakhir. Jalankan bundle update dodopayments secara berkala untuk tetap terbaru.
Kemudian jalankan: 
bundle install
SDK mendukung Ruby 3.2.0 dan versi yang lebih baru, dengan tipe lengkap, penanganan kesalahan, dan mekanisme retry.

​
Memulai dengan Cepat

Inisialisasi klien dan buat sesi 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)
Simpan kunci API Anda dengan aman menggunakan variabel lingkungan. Jangan pernah meng-commit atau mengeksposnya di kode Anda.

​
Fitur Utama

Ruby Conventions

Mengikuti konvensi penamaan Ruby dan pola idiomatis

Elegant Syntax

API yang bersih dan mudah dibaca, terasa alami untuk pengembang Ruby

Auto-Pagination

Iterator auto-paging bawaan untuk respons daftar

Type Safety

Tipe Sorbet opsional untuk keamanan tipe yang lebih baik

​
Konfigurasi

​
Konfigurasi Timeout

Konfigurasi timeout permintaan: 
# 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}
)

​
Konfigurasi Pengulangan

Konfigurasi perilaku pengulangan otomatis: 
# 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}
)

​
Operasi Umum

​
Buat Sesi Checkout

Hasilkan sesi 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

​
Kelola Pelanggan

Buat dan ambil informasi pelanggan: 
# 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})"

​
Tangani Langganan

Buat dan kelola langganan berulang: 
# 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 memerlukan setidaknya kode country ISO dua huruf. customer menerima { customer_id: "..." } untuk melampirkan pelanggan yang sudah ada atau { email: "...", name: "..." } untuk membuat pelanggan baru. product_price dalam denominasi mata uang terendah.

​
Pagination

​
Auto-Pagination

Secara otomatis iterasi melalui semua halaman: 
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

​
Manual Pagination

Untuk kontrol lebih lanjut atas paginasi: 
page = dodo_payments.payments.list

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

​
Penanganan Kesalahan

Tangani berbagai kesalahan 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
Implementasikan logika retry dengan eksponensial backoff untuk kesalahan batasan jumlah agar aplikasi Anda dapat menangani skenario volume tinggi dengan lancar.

​
Keamanan Tipe dengan Sorbet

Gunakan Sorbet untuk parameter permintaan yang aman tipe: 
# 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)

​
Penggunaan Lanjutan

​
Endpoint Tidak Terdokumentasi

Lakukan permintaan ke endpoint yang tidak terdokumentasi: 
response = dodo_payments.request(
  method: :post,
  path: '/undocumented/endpoint',
  query: {"dog": "woof"},
  headers: {"useful-header": "interesting-value"},
  body: {"hello": "world"}
)

​
Parameter Tidak Terdokumentasi

Kirim parameter yang tidak terdokumentasi: 
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])

​
Integrasi Rails

​
Buat Inisiator

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

​
Pola Objek Layanan

Buat layanan pembayaran: 
# 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

​
Integrasi Controller

Gunakan di controller Rails Anda: 
# 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

​
Integrasi Sinatra

Gunakan dengan aplikasi 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

​
Sumber Daya

GitHub Repository

Lihat kode sumber dan ikut berkontribusi

API Reference

Dokumentasi lengkap API

Discord Community

Dapatkan bantuan dan hubungi pengembang

Report Issues

Laporkan bug atau minta fitur

​
Dukungan

Butuh bantuan dengan Ruby SDK?

​
Kontribusi

Kami menyambut kontribusi! Periksa panduan kontribusi untuk memulai.
Last modified on May 14, 2026