Passer au contenu 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.

Le SDK PHP offre un moyen robuste et flexible d’intégrer Dodo Payments dans vos applications PHP. Construit selon les normes PHP modernes avec autoloading PSR-4, il offre une couverture de test étendue et une documentation détaillée.

​
Installation

Installez le SDK avec Composer : 
composer require "dodopayments/client 6.7.1"
Le SDK nécessite PHP 8.1.0 ou une version supérieure et Composer pour la gestion des dépendances.

​
Démarrage rapide

Initialisez le client et créez une session de paiement : 
<?php

use Dodopayments\Client;

$client = new Client(
  bearerToken: getenv('DODO_PAYMENTS_API_KEY') ?: 'My Bearer Token',
  environment: 'test_mode',
);

$checkoutSessionResponse = $client->checkoutSessions->create(
  productCart: [["productID" => "product_id", "quantity" => 1]]
);

var_dump($checkoutSessionResponse->session_id);
Stockez vos clés API de manière sécurisée en utilisant des variables d’environnement. Ne les exposez jamais dans votre base de code ni ne les validez dans le contrôle de version.

​
Fonctionnalités principales

PSR-4 Compliant

Suit les recommandations PHP Standards pour le développement PHP moderne

Modern PHP

Conçu pour PHP 8.1+ avec déclarations de type et types stricts

Extensive Testing

Couverture de tests complète pour garantir fiabilité et stabilité

Exception Handling

Types d’exception clairs pour les différents scénarios d’erreur

​
Objets valeur

Le SDK utilise des paramètres nommés pour spécifier les arguments optionnels. Vous pouvez initialiser les objets valeur en utilisant le constructeur statique with : 
<?php

use Dodopayments\Customers\AttachExistingCustomer;

// Recommended: Use static 'with' constructor with named parameters
$customer = AttachExistingCustomer::with(customerID: "customer_id");
Des builders sont également disponibles comme motif alternatif : 
<?php

use Dodopayments\Customers\AttachExistingCustomer;

// Alternative: Use builder pattern
$customer = (new AttachExistingCustomer)->withCustomerID("customer_id");

​
Configuration

​
Configuration des nouvelles tentatives

Certaines erreurs sont automatiquement relancées 2 fois par défaut avec un court délai exponentiel. Les erreurs suivantes déclenchent des relances automatiques :
  • Erreurs de connexion (problèmes de connectivité réseau)
  • 408 Request Timeout
  • 409 Conflict
  • 429 Rate Limit
  • Erreurs internes 500+
  • Délais d’attente dépassés
Configurez le comportement de relance globalement ou par requête : 
<?php

use Dodopayments\Client;

// Configure default for all requests (disable retries)
$client = new Client(requestOptions: ['maxRetries' => 0]);

// Or, configure per-request
$result = $client->checkoutSessions->create(
  productCart: [["productID" => "product_id", "quantity" => 1]],
  requestOptions: ['maxRetries' => 5],
);

​
Opérations courantes

​
Créer une session de paiement

Générez une session de paiement : 
$session = $client->checkoutSessions->create(
  productCart: [
    ["productID" => "prod_123", "quantity" => 1]
  ],
  returnUrl: "https://yourdomain.com/return"
);

header('Location: ' . $session->url);

​
Gérer les clients

Créez et récupérez les informations clients : 
// Create a customer
$customer = $client->customers->create(
  email: "customer@example.com",
  name: "John Doe",
  metadata: [
    "user_id" => "12345"
  ]
);

// Retrieve customer
$customer = $client->customers->retrieve("cus_123");
echo "Customer: {$customer->name} ({$customer->email})";

​
Gérer les abonnements

Créez et gérez des abonnements récurrents : 
use Dodopayments\Customers\AttachExistingCustomer;
use Dodopayments\Payments\BillingAddress;

// Create a subscription
$subscription = $client->subscriptions->create(
  billing: BillingAddress::with(
    country: 'US',
    city: 'San Francisco',
    state: 'CA',
    street: '1 Market St',
    zipcode: '94105',
  ),
  customer: AttachExistingCustomer::with(customerID: 'cus_123'),
  productID: 'pdt_456',
  quantity: 1,
);

// Charge an on-demand subscription
// productPrice is in the lowest currency denomination (e.g., 2500 = $25.00 USD)
$charge = $client->subscriptions->charge(
  $subscription->subscription_id,
  productPrice: 2500,
);
billing nécessite au moins le code ISO country à deux lettres. Passez AttachExistingCustomer::with(customerID: '...') pour attacher un client existant, ou NewCustomer::with(email: '...', name: '...') pour en créer un. productPrice est dans la plus petite dénomination monétaire.

​
Pagination

Travaillez avec des réponses de liste paginées : 
$page = $client->payments->list();

var_dump($page);

// Fetch items from the current page
foreach ($page->getItems() as $item) {
  var_dump($item->brand_id);
}

// Auto-paginate: fetch items from all pages
foreach ($page->pagingEachItem() as $item) {
  var_dump($item->brand_id);
}

​
Gestion des erreurs

Lorsque la bibliothèque ne peut pas se connecter à l’API ou reçoit un code d’état de non-succès (4xx ou 5xx), une sous-classe de APIException est lancée : 
<?php

use Dodopayments\Core\Exceptions\APIConnectionException;
use Dodopayments\Core\Exceptions\RateLimitException;
use Dodopayments\Core\Exceptions\APIStatusException;

try {
  $checkoutSessionResponse = $client->checkoutSessions->create(
    productCart: [["productID" => "product_id", "quantity" => 1]]
  );
} catch (APIConnectionException $e) {
  echo "The server could not be reached", PHP_EOL;
  var_dump($e->getPrevious());
} catch (RateLimitException $_) {
  echo "A 429 status code was received; we should back off a bit.", PHP_EOL;
} catch (APIStatusException $e) {
  echo "Another non-200-range status code was received", PHP_EOL;
  echo $e->getMessage();
}

​
Types d’erreurs

CauseType d’erreur
HTTP 400BadRequestException
HTTP 401AuthenticationException
HTTP 403PermissionDeniedException
HTTP 404NotFoundException
HTTP 409ConflictException
HTTP 422UnprocessableEntityException
HTTP 429RateLimitException
HTTP >= 500InternalServerException
Autre erreur HTTPAPIStatusException
ExpirationAPITimeoutException
Erreur réseauAPIConnectionException
Toujours encapsuler les appels d’API dans des blocs try-catch pour gérer gracieusement les erreurs potentielles et fournir un retour d’information significatif aux utilisateurs.

​
Utilisation avancée

​
Points de terminaison non documentés

Faites des requêtes vers des points de terminaison non documentés : 
<?php

$response = $client->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 à n’importe quel point de terminaison ou lisez des propriétés de réponse non documentées : 
<?php

use Dodopayments\RequestOptions;

$checkoutSessionResponse = $client->checkoutSessions->create(
  productCart: [["productID" => "product_id", "quantity" => 1]],
  requestOptions: [
    'extraQueryParams' => ["my_query_parameter" => "value"],
    'extraBodyParams' => ["my_body_parameter" => "value"],
    'extraHeaders' => ["my-header" => "value"],
  ],
);
Les paramètres extra* ayant le même nom remplacent les paramètres documentés.

​
Intégration au framework

​
Laravel

Créez un service pour les applications Laravel : 
<?php

namespace App\Services;

use Dodopayments\Client;

class PaymentService
{
    protected $client;

    public function __construct()
    {
        $this->client = new Client(
            bearerToken: config('services.dodo.api_key')
        );
    }

    public function createCheckout(array $items)
    {
        return $this->client->checkoutSessions->create(
            productCart: $items,
            returnUrl: route('checkout.return')
        );
    }
}
Ajoutez la configuration dans config/services.php : 
'dodo' => [
    'api_key' => env('DODO_API_KEY'),
    'environment' => env('DODO_ENVIRONMENT', 'sandbox')
],

​
Symfony

Créez un service dans Symfony : 
<?php

namespace App\Service;

use Dodopayments\Client;

class DodoPaymentService
{
    private Client $client;

    public function __construct(string $apiKey)
    {
        $this->client = new Client(bearerToken: $apiKey);
    }

    public function createPayment(int $amount, string $currency, string $customerId): object
    {
        return $this->client->payments->create(
            amount: $amount,
            currency: $currency,
            customerID: $customerId
        );
    }
}
Enregistrez dans config/services.yaml : 
services:
  App\Service\DodoPaymentService:
    arguments:
      $apiKey: "%env(DODO_API_KEY)%"

​
Ressources

GitHub Repository

Voir le code source et contribuer

API Reference

Documentation complète de l’API

Discord Community

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

Report Issues

Signalez des bugs ou demandez des fonctionnalités

​
Support

Besoin d’aide avec le SDK PHP ?

​
Contribuer

Nous accueillons les contributions ! Consultez les directives de contribution pour commencer.
Last modified on May 14, 2026