Airwallex Ruby Gem

gem 'airwallex'

require 'airwallex'

Airwallex.configure do |config|
  config.api_key = 'your_api_key'
  config.client_id = 'your_client_id'
  config.environment = :sandbox # or :production
end

# Create a payment intent
payment_intent = Airwallex::PaymentIntent.create(
  amount: 100.00,
  currency: 'USD',
  merchant_order_id: 'order_123',
  return_url: 'https://yoursite.com/return'
)

# Confirm with card details
payment_intent.confirm(
  payment_method: {
    type: 'card',
    card: {
      number: '4242424242424242',
      expiry_month: '12',
      expiry_year: '2025',
      cvc: '123'
    }
  }
)

# Create a beneficiary
beneficiary = Airwallex::Beneficiary.create(
  nickname: 'Acme Corp',
  payer_entity_type: 'COMPANY',
  transfer_methods: ['LOCAL'],
  beneficiary: {
    entity_type: 'COMPANY',
    company_name: 'Acme Corp',
    address: {
      country_code: 'AU',
      city: 'Melbourne',
      state: 'VIC',
      postcode: '3000',
      street_address: '15 William Street'
    },
    bank_details: {
      account_name: 'Acme Corp',
      account_number: '12750852',
      account_currency: 'AUD',
      bank_country_code: 'AU',
      bank_name: 'National Australia Bank',
      account_routing_type1: 'bsb',
      account_routing_value1: '083064',
      local_clearing_system: 'BANK_TRANSFER'
    }
  }
)

# Execute transfer
transfer = Airwallex::Transfer.create(
  beneficiary_id: beneficiary.id,
  source_currency: 'USD',
  transfer_method: 'LOCAL',
  amount: 1000.00,
  reason: 'Payment for services'
)

# Create a full refund
refund = Airwallex::Refund.create(
  payment_intent_id: payment_intent.id,
  amount: 100.00,
  reason: 'requested_by_customer'
)

# Create a partial refund
partial_refund = Airwallex::Refund.create(
  payment_intent_id: payment_intent.id,
  amount: 50.00
)

# List all refunds for a payment
refunds = Airwallex::Refund.list(payment_intent_id: payment_intent.id)

# Create a customer
customer = Airwallex::Customer.create(
  merchant_customer_id: 'internal_customer_001',
  email: 'customer@example.com',
  first_name: 'John',
  last_name: 'Doe'
)

# Save a payment method
payment_method = Airwallex::PaymentMethod.create(
  type: 'card',
  card: {
    number: '4242424242424242',
    expiry_month: '12',
    expiry_year: '2025',
    cvc: '123'
  },
  billing: {
    first_name: 'John',
    email: 'customer@example.com'
  }
)

# Use saved payment method
payment_intent.confirm(payment_method_id: payment_method.id)

# List customer's payment methods
methods = customer.payment_methods

# Disable a payment method (PaymentMethods have no delete/detach endpoint)
payment_method.disable

# Create a batch of transfers for bulk payouts
batch = Airwallex::BatchTransfer.create(
  request_id: "batch_#{Time.now.to_i}",
  source_currency: 'USD',
  transfers: [
    { beneficiary_id: 'ben_001', amount: 100.00, reason: 'Seller payout' },
    { beneficiary_id: 'ben_002', amount: 250.00, reason: 'Affiliate payment' },
    { beneficiary_id: 'ben_003', amount: 500.00, reason: 'Vendor payment' }
  ]
)

# Check batch status
batch = Airwallex::BatchTransfer.retrieve(batch.id)
puts "Completed: #{batch.success_count}/#{batch.total_count}"

# Check individual transfer statuses
batch.transfers.each do |transfer|
  puts "#{transfer.id}: #{transfer.status}"
end

# List all open disputes
disputes = Airwallex::Dispute.list(status: 'OPEN')

# Get specific dispute
dispute = Airwallex::Dispute.retrieve('dis_123')
puts "Dispute amount: #{dispute.amount} #{dispute.currency}"
puts "Reason: #{dispute.reason}"
puts "Evidence due: #{dispute.evidence_due_by}"

# Challenge the dispute with evidence
dispute.challenge(
  customer_communication: 'Email showing delivery confirmation',
  shipping_tracking_number: '1Z999AA10123456784',
  shipping_documentation: 'Proof of delivery with signature'
)

# Or accept dispute without challenging
dispute.accept

# List the payment intents related to a dispute
dispute.related_payment_intents

# Get real-time exchange rate
rate = Airwallex::Rate.retrieve(
  buy_currency: 'EUR',
  sell_currency: 'USD'
)
puts "Current rate: #{rate.client_rate}"

# Lock in a rate with a quote (valid for 24 hours)
quote = Airwallex::Quote.create(
  buy_currency: 'EUR',
  sell_currency: 'USD',
  sell_amount: 10000.00,
  validity: 'HR_24'
)

puts "Locked rate: #{quote.client_rate}"
puts "Expires in: #{quote.seconds_until_expiration} seconds"
puts "Is expired? #{quote.expired?}"

# Execute conversion using locked quote
conversion = Airwallex::Conversion.create(
  quote_id: quote.id,
  reason: 'Multi-currency settlement'
)

# Or convert at current market rate
conversion = Airwallex::Conversion.create(
  buy_currency: 'EUR',
  sell_currency: 'USD',
  sell_amount: 5000.00,
  reason: 'Currency exchange'
)

# Check account balances
balances = Airwallex::Balance.list
balances.each do |balance|
  next if balance.available_amount <= 0
  puts "#{balance.currency}: #{balance.available_amount} available"
end

# Get specific currency balance
usd_balance = Airwallex::Balance.retrieve('USD')
puts "USD Available: #{usd_balance.available_amount}"
puts "USD Total: #{usd_balance.total_amount}"

# Provision a VAN
account = Airwallex::GlobalAccount.create(
  country_code: 'AU',
  nick_name: 'booking_12345',
  required_features: [{ transfer_method: 'LOCAL' }]
)

# List inbound transactions for reconciliation
account.transactions.each { |txn| puts "#{txn.amount} from #{txn.remitter}" }

# Add and verify an alias (e.g. a phone number or email VAN)
alias_record = account.create_alias(type: 'PAYID_PHONE', value: '+61400000000')
alias_record.submit_verification_code(code: '123456')
account.aliases

# Manage direct debit mandates
account.mandates
mandate = account.mandate('mandate_id')
mandate.cancel

# Create a billing customer
billing_customer = Airwallex::BillingCustomer.create(
  name: 'Acme Corp',
  email: 'billing@acme.com',
  type: 'BUSINESS',
  default_billing_currency: 'AUD',
  default_legal_entity_id: connected_account.legal_entity_id,
  address: {
    street: '15 William Street',
    city: 'Melbourne',
    state: 'VIC',
    postcode: '3000',
    country_code: 'AU'
  }
)

# Define a product and a recurring price
product = Airwallex::BillingProduct.create(name: 'Pro Plan')
price = Airwallex::BillingPrice.create(
  product_id: product.id,
  currency: 'AUD',
  unit_amount: 99.00,
  pricing_model: 'PER_UNIT',
  recurring: { period: 1, period_unit: 'MONTH' }
)

# Subscriptions bill against a PaymentSource, not a PaymentConsent directly
# (see "Recurring Payments" below for how to obtain one)
subscription = Airwallex::BillingSubscription.create(
  billing_customer_id: billing_customer.id,
  currency: 'AUD',
  collection_method: 'AUTO_CHARGE',
  legal_entity_id: connected_account.legal_entity_id,
  payment_source_id: payment_source.id,
  starts_at: '2026-09-01T00:00:00+1000',
  items: [{ price_id: price.id, quantity: 1 }]
)

# Inspect subscription line items
subscription.items

# Consent to future merchant-initiated charges on a saved payment method
consent = Airwallex::PaymentConsent.create(
  customer_id: customer.id,
  payment_method: { id: payment_method.id },
  next_triggered_by: 'merchant',
  merchant_trigger_reason: 'unscheduled'
)
consent.verify(payment_method: { card: { cvc: '123' } })

# Wrap the consented payment method as a Payment Source for Billing
# external_id is the PaymentMethod's id, not the PaymentConsent's id
payment_source = Airwallex::PaymentSource.create(
  billing_customer_id: billing_customer.id,
  external_id: payment_method.id,
  linked_payment_account_id: connected_account.id
)

# Onboard a connected account
# account_details is a required top-level wrapper; nickname/primary_contact/
# customer_agreements are top-level siblings, not nested inside it.
connected_account = Airwallex::ConnectedAccount.create(
  nickname: 'Sub-merchant Co',
  primary_contact: { email: 'contact@submerchant.com' },
  customer_agreements: {
    agreed_to_terms_and_conditions: true,
    agreed_to_data_usage: true,
    terms_and_conditions: { service_agreement_type: 'FULL' }
  },
  account_details: {
    legal_entity_type: 'BUSINESS',
    business_details: {
      business_name: 'Sub-merchant Co',
      business_structure: 'COMPANY'
    }
  }
)
connected_account.legal_entity_id
connected_account.agree_to_terms_and_conditions
connected_account.submit

# Inspect the platform's own account
Airwallex::ConnectedAccount.current
Airwallex::ConnectedAccount.wallet_info

# Split part of a PaymentIntent's funds to a connected account. One split per
# destination: create several splits to pay several connected accounts.
# A reused request_id raises BadRequestError (duplicate_request); splitting
# more than the PaymentIntent amount raises amount_above_limit.
split = Airwallex::FundsSplit.create(
  request_id: 'split-order-123',  # required, max 64
  source_id: payment_intent.id,   # required
  source_type: 'PAYMENT_INTENT',  # required
  amount: '10.00',                # required, string
  destination: connected_account.id,
  auto_release: false,            # optional, default true
  metadata: { order_id: '123' }   # optional
)
split.release # only needed when auto_release: false

# Reverse split funds back to the platform. Partial reversals are allowed
# until the full split is reversed. Statuses: CREATED, RELEASED, SETTLED
reversal = Airwallex::FundsSplitReversal.create(
  request_id: 'rev-order-123',    # required, max 64
  funds_split_id: split.id,       # required
  amount: '5.00',                 # required, string
  metadata: { reason: 'refund' }  # optional
)
Airwallex::FundsSplitReversal.retrieve(reversal.id)
Airwallex::FundsSplitReversal.list(funds_split_id: split.id) # funds_split_id is required

# Move funds between the platform and a connected account's wallet. Pass
# x-on-behalf-of to debit a connected account instead of the platform.
# Statuses: NEW, PENDING, SETTLED, SUSPENDED, FAILED
cat = Airwallex::ConnectedAccountTransfer.create(
  request_id: 'top-up-123',       # required, 1-50
  amount: '100.00',
  currency: 'AUD',
  destination: connected_account.id,
  reason: 'transfer_to_own_account',
  reference: 'Ledger top-up'      # required, 1-140
)
Airwallex::ConnectedAccountTransfer.retrieve(cat.id)
Airwallex::ConnectedAccountTransfer.list(destination: connected_account.id, status: 'SETTLED')

# Pay out from a connected account: create the Transfer on its behalf
Airwallex::Transfer.create(transfer_params, headers: { 'x-on-behalf-of' => connected_account.id })

# Charges (create, retrieve, list)
charge = Airwallex::Charge.retrieve('charge_id')

headers = { 'x-on-behalf-of' => 'acct_123' }

rfi = Airwallex::RFI.retrieve('rfi_123', headers: headers)
rfi.status                           # => "ACTION_REQUIRED"
rfi.active_request[:questions].first # => { id: ..., title: { en: ... }, answer: { type: "ATTACHMENT" }, ... }

# statuses/types are comma-separated strings; page_size is 1-2000 (default 100)
Airwallex::RFI.list({ statuses: 'ACTION_REQUIRED', types: 'KYC,KYC_ONGOING' }, headers: headers)
              .auto_paging_each { |r| puts r.id }

passport = Airwallex::UploadedFile.upload(
  File.open('passport.jpg', 'rb'),
  filename: 'passport.jpg',
  content_type: 'image/jpeg',
  notes: 'passport-front',
  opts: { headers: headers }
)

rfi = Airwallex::RFI.retrieve('rfi_123', headers: headers)
rfi.respond(
  {
    questions: [
      { id: 'q1', answer: { type: 'TEXT', text: 'We only operate in Australia' } },
      { id: 'q2', answer: { type: 'ATTACHMENT', attachments: [{ file_id: passport.file_id }] } },
      { id: 'q3', answer: { type: 'CONFIRMATION', confirmed: true } }
    ]
  },
  headers: headers
)
rfi.status # => "ANSWERED"

code_verifier = SecureRandom.urlsafe_base64(64)
code_challenge = Base64.urlsafe_encode64(Digest::SHA256.digest(code_verifier), padding: false)

Airwallex::EmbeddedComponent.authorize(
  code_challenge: code_challenge,
  scope: ['transfer:write'], # beneficiary and payout components
  headers: { 'x-on-behalf-of' => 'acct_123' }
)
# => { authorization_code: "..." }

# Simulate an inbound bank transfer landing in a Global Account — auto-settles
# on its own within a few seconds, same as a real bank transfer
Airwallex::Deposit.simulate_create(amount: 100.00, global_account_id: 'gacc_123')

# .simulate_settle/.simulate_reject/.simulate_reverse are for Direct Debit
# deposits specifically, made via the real (non-simulation) .create — a real
# direct debit pull takes days to clear, so the sandbox needs a way to force it
pending = Airwallex::Deposit.create(funding_source_id: 'la_123', amount: 50.00, currency: 'AUD')
pending.simulate_settle # -> SETTLED
# or: pending.simulate_reject -> REJECTED

# Reversing only works on an already-SETTLED Direct Debit deposit; it creates
# an offsetting settled deposit and deactivates the LinkedAccount
settled = Airwallex::Deposit.create(funding_source_id: 'la_123', amount: 50.00, currency: 'AUD')
settled.simulate_settle
settled.simulate_reverse

# Class-level equivalents take a deposit_id directly instead of an instance
Airwallex::Deposit.simulate_settle('dpt_123')
Airwallex::Deposit.simulate_reject('dpt_123')
Airwallex::Deposit.simulate_reverse('dpt_123')

# Authorize, then capture in full
txn = Airwallex::IssuingTransaction.simulate_create(
  card_id: 'card_123',
  transaction_amount: 25.00,
  transaction_currency: 'USD'
)
Airwallex::IssuingTransaction.simulate_capture(txn.transaction_id)

# Authorize, then capture only part of the authorized amount
txn = Airwallex::IssuingTransaction.simulate_create(
  card_id: 'card_123', transaction_amount: 25.00, transaction_currency: 'USD'
)
Airwallex::IssuingTransaction.simulate_capture(txn.transaction_id, transaction_amount: 10.00)

# Authorize and clear in a single step (no separate capture needed)
Airwallex::IssuingTransaction.simulate_create(
  card_id: 'card_123', transaction_amount: 25.00, transaction_currency: 'USD', single_phase: true
)

# Reverse a still-PENDING (uncaptured) authorization instead of capturing it
txn = Airwallex::IssuingTransaction.simulate_create(
  card_id: 'card_123', transaction_amount: 25.00, transaction_currency: 'USD'
)
Airwallex::IssuingTransaction.simulate_reverse(txn.transaction_id)

# Refund a CAPTURED transaction back to the card
Airwallex::IssuingTransaction.simulate_refund(
  card_id: 'card_123', transaction_amount: 25.00, transaction_currency: 'USD'
)

# Simulate a 3DS delegation-mode notification for a card
Airwallex::IssuingTransaction.simulate_notify_three_ds(card_number: '4111111111111111')

# Full lifecycle: raised, challenged, then resolved in the merchant's favor
dispute = Airwallex::Dispute.simulate_create(
  payment_intent_id: payment_intent.id,
  reason_code: '4853',
  stage: 'CHARGEBACK',
  due_at: (Time.now + 86_400).iso8601
)
dispute.challenge(customer_communication: 'Proof of delivery')
dispute.simulate_resolve(in_favor_of: 'MERCHANT')

# Or accept without challenging, then resolve in the customer's favor
dispute = Airwallex::Dispute.simulate_create(
  payment_intent_id: payment_intent.id, reason_code: '4853', stage: 'CHARGEBACK',
  due_at: (Time.now + 86_400).iso8601
)
dispute.accept
dispute.simulate_resolve(in_favor_of: 'CUSTOMER')

# Escalate — the issuing bank rejects the challenge evidence and advances the
# dispute to the next stage (e.g. Chargeback -> Pre-arbitration)
dispute.challenge(customer_communication: 'Proof of delivery')
dispute.simulate_escalate(due_at: (Time.now + 86_400).iso8601)

# Class-level equivalents take a dispute_id directly instead of an instance
Airwallex::Dispute.simulate_escalate('dis_123', due_at: (Time.now + 86_400).iso8601)
Airwallex::Dispute.simulate_resolve('dis_123', in_favor_of: 'MERCHANT')

# Advance a transfer's status one step at a time: SCHEDULED -> PROCESSING ->
# SENT -> PAID
transfer.simulate_transition(next_status: 'PROCESSING')
transfer.simulate_transition(next_status: 'SENT')
transfer.simulate_transition(next_status: 'PAID')

# OVERDUE, FAILED, and CANCELLED can be jumped to directly
transfer.simulate_transition(next_status: 'FAILED', failure_type: 'INSUFFICIENT_FUNDS')

# Class-level equivalent takes a transfer_id directly instead of an instance
Airwallex::Transfer.simulate_transition('tfr_123', next_status: 'CANCELLED')

# A transfer created x-on-behalf-of a connected account can only be found
# with the same header (cancel takes it too)
headers = { 'x-on-behalf-of' => 'acct_123' }
transfer.simulate_transition(next_status: 'SENT', headers: headers)
Airwallex::Transfer.simulate_transition('tfr_123', next_status: 'PAID', headers: headers)
transfer.cancel(headers: headers)

# Simulate a KYC/KYB review outcome (account must currently be SUBMITTED)
connected_account.simulate_update_status(next_status: 'ACTIVE')
# or: connected_account.simulate_update_status(next_status: 'SUSPENDED')
# or: connected_account.simulate_update_status(next_status: 'ACTION_REQUIRED')

# Class-level equivalent takes an account_id directly instead of an instance
Airwallex::ConnectedAccount.simulate_update_status('acct_123', next_status: 'ACTIVE')

# Simulate a pending offboarding completing or being cancelled — via the
# parent ConnectedAccount instance...
connected_account.simulate_complete_offboarding('obd_456')
connected_account.simulate_cancel_offboarding('obd_456')

# ...or directly against AccountOffboarding with both ids
Airwallex::AccountOffboarding.simulate_complete('acct_123', 'obd_456')
Airwallex::AccountOffboarding.simulate_cancel('acct_123', 'obd_456')

amendment = Airwallex::AccountAmendment.create(
  target: 'account_details.store_details',
  store_details: { store_name: 'New Store Name' }
)
amendment.simulate_approve
# or: amendment.simulate_reject

# Class-level equivalents take an amendment_id directly instead of an instance
Airwallex::AccountAmendment.simulate_approve('amd_123')
Airwallex::AccountAmendment.simulate_reject('amd_123')

# Mandate lifecycle: PROCESSING -> ACTIVE, or PROCESSING -> INACTIVE. All
# four actions return HTTP 200 with an empty body, so the gem returns `true`
# rather than a resource instance.
Airwallex::LinkedAccount.simulate_accept_mandate('la_123')  # PROCESSING -> ACTIVE
Airwallex::LinkedAccount.simulate_reject_mandate('la_123')  # PROCESSING -> INACTIVE
Airwallex::LinkedAccount.simulate_cancel_mandate('la_123')  # PROCESSING or ACTIVE -> INACTIVE

# Simulate a failed micro-deposit verification: REQUIRES_ACTION -> FAILED
Airwallex::LinkedAccount.simulate_fail_microdeposits('la_123')

# Simulate the shopper completing (or abandoning) a redirect/3DS challenge
# raised during PaymentIntent#confirm, using the url from its next_action
payment_intent.simulate_shopper_pay(url: next_action_url)
# or: payment_intent.simulate_shopper_reject(url: next_action_url)

# Simulate the shopper completing a redirect/3DS challenge raised during
# PaymentConsent#verify, using the url from its next_action
payment_consent.simulate_shopper_verify(url: next_action_url)

# Bypass a cardholder's pending RFI review stage
Airwallex::Cardholder.simulate_pass_review('chd_123')

# Raise a KYC RFI, then close it
rfi = Airwallex::RFI.simulate_create(type: 'KYC', questions: [{ answer: { type: 'TEXT' } }])
rfi.simulate_close

# Follow up on an RFI — reopen an existing answered question (by id) or
# append a new one
rfi = Airwallex::RFI.simulate_create(type: 'KYC', questions: [{ answer: { type: 'TEXT' } }])
rfi.simulate_follow_up(questions: [{ answer: { type: 'TEXT' } }])

# Class-level equivalents take an rfi_id directly instead of an instance
Airwallex::RFI.simulate_close('rfi_123')
Airwallex::RFI.simulate_follow_up('rfi_123', questions: [{ answer: { type: 'TEXT' } }])

# Raise an RFI against a connected account — params need braces when
# followed by opts. Fails with BadRequestError ("ongoing RFI case exists")
# if the account already has an open RFI.
Airwallex::RFI.simulate_create(
  { type: 'KYC', questions: [{ answer: { type: 'TEXT' } }] },
  headers: { 'x-on-behalf-of' => 'acct_123' }
)

# Turn a terminal on, then have it confirm a PaymentIntent under a named test
# scenario
Airwallex::POSTerminal.simulate_turn_on(terminal_id: 'term_123')
Airwallex::POSTerminal.simulate_confirm_payment_intent(
  terminal_id: 'term_123', payment_scenario_name: 'approve'
)
Airwallex::POSTerminal.simulate_turn_off(terminal_id: 'term_123')

# List the test scenario names available to simulate_confirm_payment_intent
Airwallex::POSTerminal.simulate_payment_scenarios

# Generate a terminal activation code
Airwallex::POSTerminal.simulate_generate_activation_code(request_id: 'req_123')

Airwallex.configure do |config|
  config.api_key = 'your_api_key'
  config.client_id = 'your_client_id'
  config.environment = :sandbox # or :production
end

# Automatic request_id generation
transfer = Airwallex::Transfer.create(
  amount: 500.00,
  beneficiary_id: 'ben_123'
  # request_id automatically generated
)

# Or provide your own for reconciliation
transfer = Airwallex::Transfer.create(
  amount: 500.00,
  beneficiary_id: 'ben_123',
  request_id: 'my_internal_id_789'
)

# Auto-pagination with enumerable
Airwallex::Transfer.list.auto_paging_each do |transfer|
  puts transfer.id
end

# Manual pagination
transfers = Airwallex::Transfer.list(page_size: 50)
while transfers.has_more?
  transfers.each { |t| process(t) }
  transfers = transfers.next_page
end

# In your webhook controller
payload = request.body.read
signature = request.headers['x-signature']
timestamp = request.headers['x-timestamp']

begin
  event = Airwallex::Webhook.construct_event(
    payload,
    signature,
    timestamp,
    tolerance: 300 # 5 minutes
  )

  case event.name
  when 'payment_intent.succeeded'
    handle_successful_payment(event.data)
  when 'payout.transfer.failed'
    handle_failed_payout(event.data)
  when 'funds_split.settled'
    # funds_split.* payloads identify the split by split_id (not id) and
    # carry no request_id — see the Scale section
    handle_settled_split(event.data)
  end
rescue Airwallex::SignatureVerificationError => e
  # Invalid signature
  head :bad_request
end

begin
  transfer = Airwallex::Transfer.create(params)
rescue Airwallex::InsufficientFundsError => e
  # Handle insufficient balance
  notify_user("Insufficient funds: #{e.message}")
rescue Airwallex::RateLimitError => e
  # Rate limit hit - automatic retry with backoff
  retry_with_backoff
rescue Airwallex::AuthenticationError => e
  # Invalid credentials
  log_error("Auth failed: #{e.message}")
rescue Airwallex::APIError => e
  # General API error
  log_error("API error: #{e.code} - #{e.message}")
end

# In bin/console or irb
require 'airwallex'

Airwallex.configure do |config|
  config.environment = :sandbox
  config.api_key = ENV['AIRWALLEX_API_KEY']
  config.client_id = ENV['AIRWALLEX_CLIENT_ID']
end

Airwallex.configure do |config|
  config.environment = :sandbox
  config.api_key = ENV['AIRWALLEX_SANDBOX_API_KEY']
  config.client_id = ENV['AIRWALLEX_SANDBOX_CLIENT_ID']
end

Airwallex.configure do |config|
  config.environment = :production
  config.api_key = ENV['AIRWALLEX_API_KEY']
  config.client_id = ENV['AIRWALLEX_CLIENT_ID']
end

begin
  transfer = Airwallex::Transfer.create(params)
rescue Airwallex::RateLimitError => e
  sleep(2 ** retry_count)
  retry_count += 1
  retry if retry_count < 3
end