> ## 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.
# Paiement Dynamique à la Caisse avec Pay What You Want
> Créez des liens de caisse flexibles avec des prix variables en utilisant un seul produit. Activez Pay What You Want pour permettre aux clients de choisir leur prix ou de définir des montants dynamiques par programmation.
**Le prix dynamique** vous permet d'offrir des prix variables pour vos produits sans créer plusieurs entrées de produit. En activant **Pay What You Want (PWYW)** sur un seul produit, vous pouvez définir des limites de prix minimum et maximum, puis passer des montants dynamiques lors de la création de liens de session de caisse.
Cette approche est idéale lorsque vous avez besoin de :
* **Prix variables** sans gérer plusieurs produits
* **Prix déterminé par le client** où les acheteurs choisissent leur montant
* **Contrôle de prix programmatique** où vous définissez le montant dynamiquement via l'API
* **Modèles de prix flexibles** pour des produits numériques, des dons ou des lancements expérimentaux
Pay What You Want est uniquement disponible pour les produits **Paiement unique** (paiement ponctuel). Il ne peut pas être utilisé avec des produits d’abonnement.
## Comment ça fonctionne
Avec Pay What You Want activé, vous pouvez :
1. **Définissez les limites de prix** : Définissez un prix minimum (obligatoire) et éventuellement un prix maximum
2. **Transmettez des montants dynamiques** : Incluez un champ `amount` dans le panier du produit lors de la création de sessions de paiement
3. **Laissez les clients choisir** : Si aucun montant n’est fourni, les clients peuvent saisir leur propre prix (dans les limites que vous avez définies)
Lorsque vous transmettez un champ `amount` dans le panier du produit, ce montant est utilisé pour le paiement. Si vous omettez le champ `amount`, les clients peuvent choisir leur propre prix lors du paiement (sous réserve de vos paramètres minimum/maximum).
## Étape 1 : Créer un produit avec Pay What You Want
Tout d'abord, créez un produit unique dans votre tableau de bord Dodo Payments et activez le prix Pay What You Want.
Accédez à **Products** dans votre tableau de bord Dodo Payments et cliquez sur **Add Product**.
Remplissez les informations obligatoires du produit :
* **Product Name** : Nom affiché de votre produit
* **Product Description** : Description claire de ce que les clients achètent
* **Product Image** : Téléversez une image (PNG/JPG/WebP, jusqu’à 3 Mo)
* **Tax Category** : Sélectionnez la catégorie fiscale appropriée
Sélectionnez **Pricing Type** comme **Single Payment** (paiement unique).
Dans la section **Pricing**, activez le bouton **Pay What You Want**.
Saisissez le **Prix minimum** que les clients doivent payer. Cela est obligatoire et vous garantit un plancher de revenus.
**Exemple** : Si votre minimum est de 5,00 \$, saisissez `5.00` (ou `500` cents).
Facultativement, définissez un **Prix maximum** pour plafonner le montant que les clients peuvent payer.
Facultativement, saisissez un **Prix suggéré** qui sera affiché pour orienter les clients. Cela permet d’ancrer les attentes et peut améliorer la valeur moyenne des commandes.
Cliquez sur **Add Product** pour enregistrer. Notez l’ID de votre produit (par ex. `pdt_123abc456def`) pour l’utiliser dans les sessions de paiement.
Vous pouvez trouver l’ID de votre produit dans le tableau de bord sous **Products** → **View Details**, ou en utilisant l’[API List Products](/api-reference/products/get-products).
## Étape 2 : Créer des sessions de caisse avec des prix dynamiques
Une fois votre produit configuré avec Pay What You Want, vous pouvez créer des sessions de paiement avec des montants dynamiques. Le champ `amount` dans le panier du produit permet de définir le prix programmatiquement pour chaque session.
### Comprendre le champ Montant
Lors de la création d’une session de paiement, vous pouvez inclure un champ `amount` dans chaque article du panier de produit :
* **Si `amount` est fourni** : Le paiement utilise ce montant exact (doit respecter vos limites minimum/maximum)
* **Si `amount` est omis** : Les clients peuvent saisir leur propre prix lors du paiement (dans vos limites)
Le champ `amount` ne s’applique qu’aux produits Pay What You Want. Pour les produits classiques, ce champ est ignoré.
### Exemples de Code
```typescript TypeScript theme={null}
import DodoPayments from 'dodopayments';
// Initialize the Dodo Payments client
const client = new DodoPayments({
bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});
async function createDynamicPricingCheckout(
productId: string,
amountInCents: number,
returnUrl: string
) {
try {
const session = await client.checkoutSessions.create({
product_cart: [
{
product_id: productId,
quantity: 1,
// Dynamic amount in cents (e.g., 1500 = $15.00)
amount: amountInCents
}
],
return_url: returnUrl,
// Optional: Pre-fill customer information
customer: {
email: 'customer@example.com',
name: 'John Doe'
},
// Optional: Add metadata for tracking
metadata: {
order_id: 'order_123',
pricing_tier: 'custom'
}
});
console.log('Checkout URL:', session.checkout_url);
console.log('Session ID:', session.session_id);
return session;
} catch (error) {
console.error('Failed to create checkout session:', error);
throw error;
}
}
// Example: Create checkout with $25.00 (2500 cents)
const session = await createDynamicPricingCheckout(
'prod_123abc456def',
2500, // $25.00 in cents
'https://yoursite.com/checkout/success'
);
// Example: Create checkout with $10.00 (1000 cents)
const session2 = await createDynamicPricingCheckout(
'prod_123abc456def',
1000, // $10.00 in cents
'https://yoursite.com/checkout/success'
);
```
```python Python theme={null}
import os
from dodopayments import DodoPayments
# Initialize the Dodo Payments client
client = DodoPayments(
bearer_token=os.environ.get("DODO_PAYMENTS_API_KEY"),
)
def create_dynamic_pricing_checkout(
product_id: str,
amount_in_cents: int,
return_url: str
):
"""
Create a checkout session with dynamic pricing.
Args:
product_id: The product ID with Pay What You Want enabled
amount_in_cents: The amount in cents (e.g., 2500 for $25.00)
return_url: URL to redirect after payment completion
Returns:
Session object with checkout_url and session_id
"""
try:
session = client.checkout_sessions.create(
product_cart=[
{
"product_id": product_id,
"quantity": 1,
# Dynamic amount in cents (e.g., 1500 = $15.00)
"amount": amount_in_cents
}
],
return_url=return_url,
# Optional: Pre-fill customer information
customer={
"email": "customer@example.com",
"name": "John Doe"
},
# Optional: Add metadata for tracking
metadata={
"order_id": "order_123",
"pricing_tier": "custom"
}
)
print(f"Checkout URL: {session.checkout_url}")
print(f"Session ID: {session.session_id}")
return session
except Exception as error:
print(f"Failed to create checkout session: {error}")
raise error
# Example: Create checkout with $25.00 (2500 cents)
session = create_dynamic_pricing_checkout(
"prod_123abc456def",
2500, # $25.00 in cents
"https://yoursite.com/checkout/success"
)
# Example: Create checkout with $10.00 (1000 cents)
session2 = create_dynamic_pricing_checkout(
"prod_123abc456def",
1000, # $10.00 in cents
"https://yoursite.com/checkout/success"
)
```
**Format du montant** : Le champ `amount` doit être exprimé dans la plus petite unité de la devise. Pour l’USD, cela signifie les cents (par exemple, 25,00 \$ = `2500`). Pour les autres devises, utilisez la plus petite unité (par exemple, paise pour l’INR).
## Étape 3 : Laisser les clients choisir leur prix
Si vous souhaitez que les clients choisissent leur propre prix pendant le paiement, il suffit d’omettre le champ `amount` du panier du produit. La page de paiement affichera un champ de saisie où les clients pourront entrer n’importe quel montant dans vos limites minimum et maximum.
```typescript TypeScript theme={null}
async function createCustomerChoiceCheckout(
productId: string,
returnUrl: string
) {
try {
const session = await client.checkoutSessions.create({
product_cart: [
{
product_id: productId,
quantity: 1
// No amount field - customer will choose their price
}
],
return_url: returnUrl,
customer: {
email: 'customer@example.com',
name: 'John Doe'
}
});
return session;
} catch (error) {
console.error('Failed to create checkout session:', error);
throw error;
}
}
```
```python Python theme={null}
def create_customer_choice_checkout(
product_id: str,
return_url: str
):
"""
Create a checkout session where customers choose their own price.
"""
try:
session = client.checkout_sessions.create(
product_cart=[
{
"product_id": product_id,
"quantity": 1
# No amount field - customer will choose their price
}
],
return_url=return_url,
customer={
"email": "customer@example.com",
"name": "John Doe"
}
)
return session
except Exception as error:
print(f"Failed to create checkout session: {error}")
raise error
```
## Cas d'utilisation courants
### Cas d'utilisation 1 : Tarification par paliers en fonction du type d'utilisateur
Offrez des prix différents à différents segments de clients en utilisant le même produit :
```typescript theme={null}
// Student discount: $10.00
const studentSession = await createDynamicPricingCheckout(
'prod_123abc456def',
1000, // $10.00
'https://yoursite.com/success'
);
// Regular price: $25.00
const regularSession = await createDynamicPricingCheckout(
'prod_123abc456def',
2500, // $25.00
'https://yoursite.com/success'
);
// Premium price: $50.00
const premiumSession = await createDynamicPricingCheckout(
'prod_123abc456def',
5000, // $50.00
'https://yoursite.com/success'
);
```
### Cas d'utilisation 2 : Tarification dynamique en fonction de la quantité
Ajustez le prix en fonction de la quantité achetée :
```typescript theme={null}
async function createQuantityBasedCheckout(
productId: string,
quantity: number
) {
// Base price: $20.00 per unit
// Discount: 10% for 2+ items, 20% for 5+ items
const basePrice = 2000; // $20.00 in cents
let discount = 0;
if (quantity >= 5) {
discount = 0.20; // 20% off
} else if (quantity >= 2) {
discount = 0.10; // 10% off
}
const totalAmount = Math.round(basePrice * quantity * (1 - discount));
const session = await client.checkoutSessions.create({
product_cart: [
{
product_id: productId,
quantity: quantity,
amount: totalAmount
}
],
return_url: 'https://yoursite.com/success'
});
return session;
}
```
### Cas d'utilisation 3 : Tarification basée sur le temps ou promotionnelle
Appliquez une tarification promotionnelle pendant des périodes spécifiques :
```typescript theme={null}
async function createPromotionalCheckout(productId: string) {
const isPromoActive = checkIfPromotionActive(); // Your logic
const regularPrice = 3000; // $30.00
const promoPrice = 2000; // $20.00
const amount = isPromoActive ? promoPrice : regularPrice;
const session = await client.checkoutSessions.create({
product_cart: [
{
product_id: productId,
quantity: 1,
amount: amount
}
],
return_url: 'https://yoursite.com/success',
metadata: {
pricing_type: isPromoActive ? 'promotional' : 'regular'
}
});
return session;
}
```
## Meilleures pratiques
Choisissez un prix minimum qui couvre vos coûts tout en restant accessible. Utilisez un prix suggéré pour orienter les attentes des clients.
Vérifiez toujours que les montants dynamiques respectent les limites minimum et maximum de votre produit avant de créer les sessions de paiement.
Utilisez les métadonnées pour suivre les raisons pour lesquelles certains montants ont été choisis (par ex. `pricing_tier`, `discount_code`, `user_segment`).
Assurez-vous que votre application gère gracieusement les cas où les montants dépassent les limites maximales ou sont inférieurs aux minimums.
## Validation et gestion des erreurs
Validez toujours les montants par rapport aux paramètres minimum et maximum de votre produit :
```typescript TypeScript theme={null}
async function createValidatedCheckout(
productId: string,
amountInCents: number,
minAmount: number,
maxAmount: number | null
) {
// Validate minimum
if (amountInCents < minAmount) {
throw new Error(
`Amount ${amountInCents} is below minimum ${minAmount}`
);
}
// Validate maximum (if set)
if (maxAmount !== null && amountInCents > maxAmount) {
throw new Error(
`Amount ${amountInCents} exceeds maximum ${maxAmount}`
);
}
// Create checkout session
return await client.checkoutSessions.create({
product_cart: [
{
product_id: productId,
quantity: 1,
amount: amountInCents
}
],
return_url: 'https://yoursite.com/success'
});
}
```
```python Python theme={null}
def create_validated_checkout(
product_id: str,
amount_in_cents: int,
min_amount: int,
max_amount: int | None
):
"""
Create a checkout session with amount validation.
"""
# Validate minimum
if amount_in_cents < min_amount:
raise ValueError(
f"Amount {amount_in_cents} is below minimum {min_amount}"
)
# Validate maximum (if set)
if max_amount is not None and amount_in_cents > max_amount:
raise ValueError(
f"Amount {amount_in_cents} exceeds maximum {max_amount}"
)
# Create checkout session
return client.checkout_sessions.create(
product_cart=[
{
"product_id": product_id,
"quantity": 1,
"amount": amount_in_cents
}
],
return_url="https://yoursite.com/success"
)
```
## Référence API
En savoir plus sur le modèle de tarification Pay What You Want et ses capacités.
Explorez les fonctionnalités avancées des sessions de paiement et les options de personnalisation.
## Dépannage
Si votre champ `amount` est ignoré, vérifiez que :
* Le produit a **Pay What You Want** activé dans le tableau de bord
* Le produit est un produit **Single Payment** (paiement unique), pas un abonnement
* Le montant est au bon format (plus petite unité de la devise, par ex. cents pour l’USD)
L’API rejettera les sessions de paiement dont le montant viole les limites de prix de votre produit. Validez toujours les montants avant de créer les sessions de paiement, ou laissez les clients choisir leur prix en omettant le champ `amount`.
Si les clients ne voient pas le champ de saisie du prix, assurez-vous d’avoir omis le champ `amount` du panier du produit. Lorsque `amount` est fourni, le paiement utilise ce montant exact.