Guia de Integração Móvel

​

Pré-requisitos

• Conta Dodo Payments: conta de comerciante ativa com acesso à API
• Credenciais da API: chave de API e chave secreta de webhook do seu dashboard
• Projeto de aplicativo móvel: aplicativo Android, iOS, React Native ou Flutter
• Servidor de backend: para lidar com segurança com a criação de sessões de checkout

​

Fluxo de integração

func getCheckoutURL(productId: String, customerEmail: String, customerName: String) async throws -> String {
    let url = URL(string: "https://your-backend.com/api/create-checkout-session")!
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.setValue("Bearer \(userSessionToken)", forHTTPHeaderField: "Authorization")
    
    let requestData: [String: Any] = [
        "productId": productId,
        "customerEmail": customerEmail,
        "customerName": customerName
    ]
    request.httpBody = try JSONSerialization.data(withJSONObject: requestData)
    
    let (data, _) = try await URLSession.shared.data(for: request)
    let response = try JSONDecoder().decode(CheckoutResponse.self, from: data)
    return response.checkout_url
}

suspend fun getCheckoutURL(productId: String, customerEmail: String, customerName: String): String {
    val client = OkHttpClient()
    val requestBody = JSONObject().apply {
        put("productId", productId)
        put("customerEmail", customerEmail)
        put("customerName", customerName)
    }.toString().toRequestBody("application/json".toMediaType())
    
    val request = Request.Builder()
        .url("https://your-backend.com/api/create-checkout-session")
        .header("Authorization", "Bearer $userSessionToken")
        .post(requestBody)
        .build()
    
    val response = client.newCall(request).execute()
    val responseBody = response.body?.string()
    val jsonResponse = JSONObject(responseBody ?: "")
    return jsonResponse.getString("checkout_url")
}

const getCheckoutURL = async (productId, customerEmail, customerName) => {
  try {
    const response = await fetch('https://your-backend.com/api/create-checkout-session', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${userSessionToken}`,
      },
      body: JSON.stringify({
        productId,
        customerEmail,
        customerName
      })
    });
    
    const data = await response.json();
    return data.checkout_url;
  } catch (error) {
    console.error('Failed to get checkout URL:', error);
    throw error;
  }
};

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<String> getCheckoutUrl({
  required String productId,
  required String customerEmail,
  required String customerName,
}) async {
  final response = await http.post(
    Uri.parse('https://your-backend.com/api/create-checkout-session'),
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer $userSessionToken',
    },
    body: jsonEncode({
      'productId': productId,
      'customerEmail': customerEmail,
      'customerName': customerName,
    }),
  );

  if (response.statusCode != 200) {
    throw Exception('Failed to get checkout URL: ${response.statusCode}');
  }
  return jsonDecode(response.body)['checkout_url'] as String;
}

​

Escolha seu SDK

​

Registrando um esquema de URL de callback

android {
    defaultConfig {
        manifestPlaceholders["dodoCallbackScheme"] = "myapp"
    }
}

<key>CFBundleURLTypes</key>
<array>
  <dict>
    <key>CFBundleURLName</key>
    <string>myapp</string>
    <key>CFBundleURLSchemes</key>
    <array>
      <string>myapp</string>
    </array>
  </dict>
</array>

{
  "expo": {
    "scheme": "myapp",
    "plugins": [
      [
        "@dodopayments/react-native-checkout",
        { "scheme": "myappcheckout" }
      ]
    ]
  }
}

​

Personalização da aparência

const result = await DodoCheckout.start({
  checkoutUrl,
  returnUrl: 'myapp://checkout/return',
  customization: {
    android: { toolbarColor: '#6366F1', closeButtonStyle: 'back' },
    ios: { presentationStyle: 'fullScreen', colorScheme: 'dark' },
  },
});

final result = await DodoCheckout.instance.start(
  CheckoutParams(
    checkoutUrl: Uri.parse(checkoutUrl),
    returnUrl: Uri.parse('myapp://checkout/return'),
    customization: BrowserCustomization(
      android: AndroidBrowserOptions(
        toolbarColor: Color(0xFF6366F1),
        closeButtonStyle: CloseButtonStyle.back,
      ),
      ios: IosBrowserOptions(
        presentationStyle: PresentationStyle.fullScreen,
        colorScheme: BrowserColorScheme.dark,
      ),
    ),
  ),
);

val result = DodoCheckout.start(
    activity,
    CheckoutParams(
        checkoutUrl = checkoutUrl,
        returnUrl = "myapp://checkout/return",
        customization = BrowserCustomization(
            toolbarColor = Color.parseColor("#6366F1"),
            closeButtonStyle = BrowserCustomization.CloseButtonStyle.BACK,
        )
    )
) { event -> }

let result = try await DodoCheckout.start(
    checkoutUrl: checkoutUrl,
    returnUrl: URL(string: "myapp://checkout/return")!,
    customization: BrowserCustomization(
        presentationStyle: .fullScreen,
        colorScheme: .dark
    )
)

​

Personalização da página de checkout

​

Receitas otimizadas para dispositivos móveis

Minimal Mobile Checkout - fastest path to payment

Use esta opção quando quiser o formulário mais curto possível: métodos de pagamento no topo, apenas o CEP obrigatório para o endereço, nenhum campo de desconto e tema correspondente ao dispositivo.

• Node.js SDK
• Python SDK

import DodoPayments from 'dodopayments';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  environment: 'test_mode',
});

const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_your_product_id', quantity: 1 }],
  customer: { email: 'user@example.com', name: 'Jane Smith' },
  billing_address: { country: 'US' },
  return_url: 'myapp://checkout/success',
  cancel_url: 'myapp://checkout/cancelled',
  billing_currency: 'USD',
  minimal_address: true,
  customization: {
    show_order_details: false,
    theme: 'system',
  },
  feature_flags: {
    allow_discount_code: false,
    allow_currency_selection: false,
  },
});

console.log(session.checkout_url);

See all 26 lines

import os
import dodopayments

client = dodopayments.DodoPayments(
    bearer_token=os.environ.get("DODO_PAYMENTS_API_KEY"),
    environment="test_mode",
)

session = client.checkout_sessions.create(
    product_cart=[{"product_id": "pdt_your_product_id", "quantity": 1}],
    customer={"email": "user@example.com", "name": "Jane Smith"},
    billing_address={"country": "US"},
    return_url="myapp://checkout/success",
    cancel_url="myapp://checkout/cancelled",
    billing_currency="USD",
    minimal_address=True,
    customization={
        "show_order_details": False,
        "theme": "system",
    },
    feature_flags={
        "allow_discount_code": False,
        "allow_currency_selection": False,
    },
)

print(session.checkout_url)

See all 27 lines

Consulte Checkout Sessions para ver todos os parâmetros disponíveis e seus valores padrão.

Branded Mobile Checkout - custom colors, fonts, and button label

Use esta opção quando a página de checkout precisar parecer parte do seu aplicativo. Defina as cores da sua marca, uma fonte personalizada e um rótulo localizado para o botão de pagamento.

• Node.js SDK
• Python SDK

const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_your_product_id', quantity: 1 }],
  customer: { email: 'user@example.com', name: 'Jane Smith' },
  billing_address: { country: 'US' },
  billing_currency: 'USD',
  return_url: 'myapp://checkout/success',
  minimal_address: true,
  customization: {
    show_order_details: false,
    theme: 'dark',
    theme_config: {
      dark: {
        button_primary: '#7C3AED',
        button_primary_hover: '#6D28D9',
        button_text_primary: '#FFFFFF',
        bg_primary: '#1A1A2E',
        bg_secondary: '#16213E',
        text_primary: '#E2E8F0',
      },
      pay_button_text: 'Complete Purchase',
      radius: '8px',
    },
  },
});

See all 24 lines

session = client.checkout_sessions.create(
    product_cart=[{"product_id": "pdt_your_product_id", "quantity": 1}],
    customer={"email": "user@example.com", "name": "Jane Smith"},
    billing_address={"country": "US"},
    billing_currency="USD",
    return_url="myapp://checkout/success",
    minimal_address=True,
    customization={
        "show_order_details": False,
        "theme": "dark",
        "theme_config": {
            "dark": {
                "button_primary": "#7C3AED",
                "button_primary_hover": "#6D28D9",
                "button_text_primary": "#FFFFFF",
                "bg_primary": "#1A1A2E",
                "bg_secondary": "#16213E",
                "text_primary": "#E2E8F0",
            },
            "pay_button_text": "Complete Purchase",
            "radius": "8px",
        },
    },
)

See all 24 lines

theme_config aceita objetos separados dark e light para que a paleta se adapte à aparência atual do dispositivo. Consulte Checkout Sessions para obter a referência completa das cores.

One-Click Returning Customer - saved card, instant confirmation

Use esta opção para usuários conectados que já pagaram anteriormente. Combine um ID de cliente, o método de pagamento salvo e confirm: true para ignorar completamente o formulário de checkout.

• Node.js SDK
• Python SDK

const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_your_product_id', quantity: 1 }],
  customer: { customer_id: 'cus_returning_customer_id' },
  billing_address: { country: 'US' },
  billing_currency: 'USD',
  return_url: 'myapp://checkout/success',
  payment_method_id: 'pm_saved_payment_method_id',
  confirm: true,
  show_saved_payment_methods: true,           // top-level parameter
  feature_flags: { redirect_immediately: true },
});

See all 11 lines

session = client.checkout_sessions.create(
    product_cart=[{"product_id": "pdt_your_product_id", "quantity": 1}],
    customer={"customer_id": "cus_returning_customer_id"},
    billing_address={"country": "US"},
    billing_currency="USD",
    return_url="myapp://checkout/success",
    payment_method_id="pm_saved_payment_method_id",
    confirm=True,
    show_saved_payment_methods=True,           # top-level parameter
    feature_flags={"redirect_immediately": True},
)

See all 11 lines

O status no retorno do deep link é apenas uma dica de UI. Confirme o acesso monitorando o webhook payment.succeeded no seu backend.

Subscription with Free Trial - trial before first charge

Use esta opção para produtos de assinatura que oferecem um período de teste gratuito antes do primeiro ciclo de cobrança.

• Node.js SDK
• Python SDK

const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_your_subscription_product_id', quantity: 1 }],
  customer: { email: 'user@example.com', name: 'Jane Smith' },
  billing_address: { country: 'US' },
  billing_currency: 'USD',
  return_url: 'myapp://subscription/activated',
  cancel_url: 'myapp://subscription/cancelled',
  minimal_address: true,
  customization: {
    show_order_details: false,
    theme: 'system',
  },
  subscription_data: { trial_period_days: 14 },
});

See all 14 lines

session = client.checkout_sessions.create(
    product_cart=[{"product_id": "pdt_your_subscription_product_id", "quantity": 1}],
    customer={"email": "user@example.com", "name": "Jane Smith"},
    billing_address={"country": "US"},
    billing_currency="USD",
    return_url="myapp://subscription/activated",
    cancel_url="myapp://subscription/cancelled",
    minimal_address=True,
    customization={"show_order_details": False, "theme": "system"},
    subscription_data={"trial_period_days": 14},
)

See all 11 lines

Conceda acesso ao recurso quando seu backend receber o webhook subscription.active — não quando o SDK móvel retornar. Consulte o Guia de integração de assinaturas para ver o fluxo completo do webhook.

On-Demand Mandate - save a card for future variable charges

Use esta opção para tokenizar o cartão de um cliente para cobranças posteriores (recargas de carteira, pay-as-you-go e BNPL) sem exibir um rótulo de “assinatura”. O cliente autoriza o método de pagamento uma vez; posteriormente, você cobra valores variáveis sob demanda.

Este é o padrão usado por aplicativos que cobram com base no uso — por exemplo, um aplicativo de astrologia que cobra por sessão a partir de um cartão pré-autorizado, em vez de seguir uma agenda fixa.

• Node.js SDK
• Python SDK

// Step 1: Authorize the mandate (no charge yet)
const session = await client.checkoutSessions.create({
  product_cart: [{ product_id: 'pdt_your_subscription_product_id', quantity: 1 }],
  customer: { email: 'user@example.com', name: 'Jane Smith' },
  billing_address: { country: 'US' },
  billing_currency: 'USD',
  return_url: 'myapp://mandate/authorized',
  cancel_url: 'myapp://mandate/cancelled',
  minimal_address: true,
  customization: {
    show_order_details: false,
    show_on_demand_tag: false, // hides the "on-demand" / "subscription" label
    theme: 'system',
  },
  subscription_data: {
    on_demand: { mandate_only: true },
  },
});

// Step 2: Later, charge any amount using the subscription ID
// (received via the subscription.active webhook after mandate authorization)
// await client.subscriptions.charge(subscriptionId, {
//   product_price: 2000,         // $20.00 in cents
//   product_currency: 'USD',
//   product_description: 'Session credits',
// });

See all 26 lines

# Step 1: Authorize the mandate (no charge yet)
session = client.checkout_sessions.create(
    product_cart=[{"product_id": "pdt_your_subscription_product_id", "quantity": 1}],
    customer={"email": "user@example.com", "name": "Jane Smith"},
    billing_address={"country": "US"},
    billing_currency="USD",
    return_url="myapp://mandate/authorized",
    cancel_url="myapp://mandate/cancelled",
    minimal_address=True,
    customization={
        "show_order_details": False,
        "show_on_demand_tag": False,  # hides the "on-demand" / "subscription" label
        "theme": "system",
    },
    subscription_data={"on_demand": {"mandate_only": True}},
)

# Step 2: Later, charge any amount using the subscription ID
# client.subscriptions.charge(subscription_id, {
#     "product_price": 2000,  # $20.00 in cents
#     "product_currency": "USD",
#     "product_description": "Session credits",
# })

See all 23 lines

As cobranças sob demanda exigem um mínimo de 1 USD (100 centavos). Valores abaixo de 1 USD serão rejeitados com "value out of range". Para uma autorização de valor zero, use mandate_only: true conforme mostrado acima e, depois, cobre pelo menos 1 USD nas chamadas subsequentes.

Consulte Assinaturas sob demanda para ver o fluxo completo de cobrança, os eventos de webhook e as políticas de novas tentativas.

​

Fluxos de assinatura em dispositivos móveis

​

Assinaturas recorrentes regulares

​

Assinaturas sob demanda

• Defina show_on_demand_tag: false para que a página de checkout não exiba a linguagem de “assinatura” ou “sob demanda”. Em casos de uso de tokenização de cartão, os clientes não esperam terminologia de assinatura.
• Depois que o mandato for autorizado, seu backend receberá subscription.active. Armazene subscription_id — você o usará em todas as cobranças futuras.

​

Assinatura com teste gratuito

​

Upgrades e downgrades

​

Reduzindo abandonos no checkout

​

Otimize o formulário

​

Preencha previamente os dados do cliente

• Novos clientes — defina customer.email e customer.name a partir da sua sessão de autenticação.
• Clientes recorrentes — defina customer.customer_id para preencher automaticamente todos os dados armazenados.
• Moeda — sempre passe billing_currency e billing_address.country juntos.

​

Ferramentas de recuperação

​

Práticas recomendadas

• Segurança: nunca inclua uma chave de API no aplicativo. Crie sessões de checkout no backend e passe ao cliente apenas o checkout_url resultante.
• Autoridade: trate CheckoutResult.status como uma dica de UI. Conceda acesso somente depois que o backend confirmar o pagamento.
• Experiência do usuário: mostre um estado de carregamento enquanto o backend cria a sessão e trate cancelled como um resultado normal, não como um erro.
• Testes: use o modo de teste e cartões de teste e verifique o ciclo completo da URL de retorno em um dispositivo real e também em um simulador.
• Conversão: defina show_order_details: false e minimal_address: true para obter as melhores taxas de conclusão de checkout móvel. Mover os métodos de pagamento para acima da dobra e reduzir os campos do formulário são as duas mudanças de maior impacto que você pode fazer.
• Moeda: sempre passe explicitamente billing_currency e billing_address.country — se um deles estiver ausente, Adaptive Currency poderá alterar a moeda de cobrança com base no endereço IP do cliente.
• Cobrança sob demanda: defina show_on_demand_tag: false ao usar assinaturas sob demanda para tokenização de cartão. Clientes que usam um fluxo de recarga de carteira não esperam ver a linguagem de “assinatura”.
• Recuperação: ative a recuperação de carrinhos abandonados no seu dashboard do Dodo Payments para reengajar automaticamente os clientes que não concluírem o checkout.

​

Solução de problemas

​

Problemas comuns

• O callback nunca chega: o esquema em returnUrl deve corresponder ao que você registrou. No Android, esse é o placeholder de manifest dodoCallbackScheme; no iOS e no React Native, é o tipo de URL Info.plist.
• O checkout retorna ao navegador em vez de retornar ao aplicativo (iOS): você não encaminhou a URL recebida. Chame DodoCheckout.handleOpenURL(url) de .onOpenURL, scene(_:openURLContexts:) ou de um listener Linking do React Native.
• PLATFORM_ERROR no Android: geralmente é uma incompatibilidade de esquema. Também pode ocorrer se MainActivity definir android:taskAffinity="" (o padrão flutter create), fazendo com que algumas versões de OEM percam o checkout em andamento.
• ALREADY_IN_PROGRESS: ainda há um checkout aberto. Aguarde ou dispense o anterior antes de iniciar outro.
• A compilação falha com um placeholder não resolvido: você adicionou o SDK do Android, mas nunca definiu manifestPlaceholders["dodoCallbackScheme"].
• O pagamento foi concluído, mas o acesso não foi concedido: isso é esperado se você estiver usando o resultado móvel como referência. Conceda acesso a partir do webhook payment.succeeded / subscription.active.
• Apple Pay / Google Pay não aparecem no dispositivo móvel: o checkout está sendo carregado dentro de uma WebView incorporada (WKWebView / Android WebView), que impede o funcionamento das carteiras e pode interromper o 3-D Secure. Em vez disso, abra-o com o SDK ou no navegador do sistema (Custom Tabs / SFSafariViewController).

​

Recursos adicionais

• Guia de integração de pagamentos
• Documentação de webhook
• Processo de testes
• Perguntas frequentes técnicas
• Personalização da sessão de checkout
• Assinaturas sob demanda
• Upgrade/downgrade de assinatura
• Recuperação de carrinho abandonado
• Customer Portal