Seat-Based Pricing with Add-ons and Payment Links

This tutorial shows how to implement seat-based pricing using Dodo Payments add-ons. You’ll create a subscription product with add-ons for additional seats and generate payment links with custom add-on quantities.

This tutorial uses Node.js and Express. You can adapt the code for your framework (Next.js, React, Vue, etc.) and customize the UI to match your application.

By the end of this tutorial, you’ll know how to:

Create subscription products with seat-based pricing
Set up add-ons for additional seats
Generate payment links with custom add-on quantities
Handle checkout sessions with dynamic seat counts

What We’re Building

Let’s create a seat-based pricing model:

Base Plan: $49/month for up to 5 team members
Seat Add-on: $2/month per additional seat
Payment Links: Dynamic checkout with custom seat quantities

Before we start, make sure you have:

A Dodo Payments account
Basic familiarity with TypeScript/Node.js

Step 1: Create Your Seat Add-On

Create an add-on that represents additional seats. This add-on will be attached to your base subscription and allow customers to purchase additional seats.

What we’re building: An add-on that costs $2/month per seat and can be added to any base subscription.

Navigate to Add-Ons

In your Dodo Payments dashboard, stay in the Products section
Click on the Add-Ons tab
Click Create Add-On

This will open the add-on creation form.

Enter add-on details

Fill in these values for our seat add-on:Add-On Name: Additional Team SeatDescription: Add extra team members to your workspace with full access to all featuresPrice: Enter → 2.00Currency: Must match your base subscription currencyTax Category: Select appropriate category for your product.

Save your add-on

Review all your settings:
- Name: Additional Team Seat
- Price: $2.00/month
Click Create Add-On

Add-on created! Your seat add-on is now available to attach to subscriptions.

Step 2: Create Your Base Subscription Product

Create a base subscription product that includes 5 team members. This will be the foundation of your seat-based pricing model.

Navigate to Products

Log into your Dodo Payments dashboard
Click on Products in the left sidebar
Click the Create Product button
Select Subscription as the product type

You should see a form where we’ll configure our base subscription.

Fill in the subscription details

Now we’ll enter the specific details for our base plan:Product Name: MotionDescription: Where your team's documentation lives.Recurring Price: Enter → 49.00Billing Cycle: Select → MonthlyCurrency: Select your preferred currency (e.g., USD)

Step 3: Connect Add-On to Subscription

Associate your seat add-on with the base subscription so customers can purchase additional seats during checkout.

Attach the seat add-on

Attaching add-on to subscription in the dashboard

Scroll down to the Add-Ons section
Click Add Add-Ons
From the dropdown, select your seat add-on
Confirm that it appears in your subscription configuration

Save subscription changes

Review your complete subscription setup:
- Base plan: $49/month for 5 seats
- Add-on: $2/month per additional seat
Click Save Changes

Seat-based pricing configured! Customers can now purchase your base plan and add extra seats as needed.

Step 4: Generate Payment Links with Custom Add-on Quantities

Create an Express.js application that generates payment links with custom add-on quantities. This lets you dynamically create checkout sessions with any number of additional seats.

Set up your project

Create a new Node.js project and install the required dependencies:

mkdir seat-based-pricing
cd seat-based-pricing
npm init -y
npm install dodopayments express dotenv
npm install -D @types/node @types/express typescript ts-node

Create a tsconfig.json file:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

Create your environment file

Create a .env file with your Dodo Payments API key:

DODO_PAYMENTS_API_KEY=your_actual_dodo_api_key_here

Never commit your API key to version control. Add .env to your .gitignore file.

Implement the checkout session creation

Create a src/server.ts file with the following code:

// Add this new endpoint for dynamic seat quantities
import 'dotenv/config';
import DodoPayments from 'dodopayments';
import express, { Request, Response } from 'express';

const app = express();

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

async function createCheckoutSession(seatCount: number) {
  try {
    const session = await client.checkoutSessions.create({
      // Products to sell - use IDs from your Dodo Payments dashboard
      product_cart: [
        {
          product_id: 'pdt_7Rl9OWT2Mz4wwUTKz74iZ', // Replace with your actual product ID
          quantity: 1,
          addons: [
            {
              addon_id: 'adn_eKQbNakKrivDpaxmI8wKI', // Replace with your actual addon ID
              quantity: seatCount
            }
          ]
        }
      ],
      
      // Pre-fill customer information to reduce friction
      customer: {
        email: 'steve@example.com',
        name: 'Steve Irwin',
      },
      // Where to redirect after successful payment
      return_url: 'https://example.com/checkout/success',
    });

    // Redirect your customer to this URL to complete payment
    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 usage in an Express.js route
app.post('/create-checkout/:seatCount', async (req: Request, res: Response) => {
  try {
    const seatCount = parseInt(req.params.seatCount);
    const session = await createCheckoutSession(seatCount);
    // Demo pricing from this tutorial: $49 base + $2 per additional seat
    res.json({ checkout_url: session.checkout_url, total_cost: 49 + seatCount * 2 });
  } catch (error) {
    res.status(500).json({ error: 'Failed to create checkout session' });
  }
});

// Add this line after your other middleware
app.use(express.static('public'));

// Add this route to serve the demo page
app.get('/', (req, res) => {
  res.sendFile(__dirname + '/../public/index.html');
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

Add a simple web interface

Create a public/index.html file for easy testing:

<!DOCTYPE html>
<html>
<head>
    <title>Seat-Based Pricing Demo</title>
    <style>
        body { font-family: Arial, sans-serif; max-width: 600px; margin: 50px auto; padding: 20px; }
        .form-group { margin: 20px 0; }
        label { display: block; margin-bottom: 5px; font-weight: bold; }
        input { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 4px; }
        button { background: #007bff; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; }
        button:hover { background: #0056b3; }
        .result { margin-top: 20px; padding: 15px; background: #f8f9fa; border-radius: 4px; }
    </style>
</head>
<body>
    <h1>Seat-Based Pricing Demo</h1>
    <p>Generate checkout links with custom seat quantities:</p>
    
    <div class="form-group">
        <label for="seatCount">Number of Additional Seats:</label>
        <input type="number" id="seatCount" value="3" min="0" max="50">
    </div>
    
    <button onclick="createCheckout()">Generate Checkout Link</button>
    
    <div id="result" class="result" style="display: none;">
        <h3>Checkout Link Generated!</h3>
        <p><strong>Seat Count:</strong> <span id="seatCountDisplay"></span></p>
        <p><strong>Total Cost:</strong> $<span id="totalCost"></span>/month</p>
        <p><strong>Checkout URL:</strong></p>
        <a id="checkoutUrl" href="#" target="_blank">Click here to checkout</a>
    </div>

    <script>
        async function createCheckout() {
            const seatCount = document.getElementById('seatCount').value;
            
            try {
                const response = await fetch(`/create-checkout/${seatCount}`, {
                    method: 'POST'
                });
                
                const data = await response.json();
                
                if (response.ok) {
                    document.getElementById('seatCountDisplay').textContent = seatCount;
                    document.getElementById('totalCost').textContent = data.total_cost;
                    document.getElementById('checkoutUrl').href = data.checkout_url;
                    document.getElementById('result').style.display = 'block';
                } else {
                    alert('Error: ' + data.error);
                }
            } catch (error) {
                alert('Error creating checkout session');
            }
        }
    </script>
</body>
</html>

Web interface created! You now have a simple UI to test different seat quantities.

Serve static files

Add this to your src/server.ts to serve the HTML file:

// Add this line after your other middleware
app.use(express.static('public'));

// Add this route to serve the demo page
app.get('/', (req, res) => {
  res.sendFile(__dirname + '/../public/index.html');
});

Static files configured! Visit http://localhost:3000 to see your demo interface.

Step 5: Test Your Implementation

Let’s test our seat-based pricing implementation to make sure everything works correctly.

Start your server

Make sure you have your .env file with the correct API key
Update the product and add-on IDs in your code with the actual values from your Dodo Payments dashboard
Start your server:

npx ts-node src/server.ts

Your server should start successfully and show “Server is running on port 3000”

Test the web interface

Open your browser and go to http://localhost:3000
You should see the seat-based pricing demo interface
Try different seat quantities (0, 3, 10, etc.)
Click “Generate Checkout Link” for each quantity
Verify that the checkout URLs are generated correctly

Test a checkout session

Generate a checkout link with 3 additional seats
Click the checkout URL to open the Dodo Payments checkout
Verify that the checkout shows:
- Base plan: $49/month
- Additional seats: 3 × 2 dollars = $6/month
Complete the test purchase

The checkout should display the correct pricing breakdown and allow you to complete the purchase.

Listen for webhooks and update your database

Keep your database in sync with subscription and seat changes by listening for webhook events from Dodo Payments. Webhooks notify your backend when a customer completes checkout, updates their subscription, or changes seat counts.Follow the official Dodo Payments webhooks guide for step-by-step instructions on setting up webhook endpoints and handling events:

Dodo Payments Webhooks Documentation

Learn how to securely receive and process webhook events for subscription and seat management.

Troubleshooting

Common issues and their solutions:

Checkout creation failing

Possible causes:

Invalid product ID or add-on ID
API key doesn’t have sufficient permissions
Add-on not properly associated with subscription
Network connectivity issues

Solutions:

Verify product and add-on IDs exist in your Dodo Payments dashboard
Check that add-on is properly attached to the subscription
Ensure API key has checkout session creation permissions
Test API connectivity with a simple GET request

Congratulations! You’ve Implemented Seat-Based Pricing

You’ve successfully created a seat-based pricing system with Dodo Payments. Here’s what you accomplished:

Base Subscription

Created a subscription product with 5 included seats at $49/month

Seat Add-ons

Configured add-ons for additional seats at $2/month per seat

Checkout

Built an API that generates checkout sessions with custom seat quantities

Web Interface

Created a simple web interface for testing different seat quantities

This example demonstrates a minimal implementation of seat-based pricing. For production use, add error handling, authentication, data validation, security measures, and adapt the logic to fit your application’s requirements.

Integration Guides

Billing Deconstructions

Cookbooks

Seat-Based Pricing with Add-ons and Payment Links

What We’re Building

Step 1: Create Your Seat Add-On

Step 2: Create Your Base Subscription Product

Step 3: Connect Add-On to Subscription

Step 4: Generate Payment Links with Custom Add-on Quantities

Step 5: Test Your Implementation

Dodo Payments Webhooks Documentation

Troubleshooting

Congratulations! You’ve Implemented Seat-Based Pricing

Base Subscription

Seat Add-ons

Checkout

Web Interface

​What We’re Building

​Step 1: Create Your Seat Add-On

​Step 2: Create Your Base Subscription Product

​Step 3: Connect Add-On to Subscription

​Step 4: Generate Payment Links with Custom Add-on Quantities

​Step 5: Test Your Implementation

Dodo Payments Webhooks Documentation

​Troubleshooting

​Congratulations! You’ve Implemented Seat-Based Pricing

Base Subscription

Seat Add-ons

Checkout

Web Interface

What We’re Building

Step 1: Create Your Seat Add-On

Step 2: Create Your Base Subscription Product

Step 3: Connect Add-On to Subscription

Step 4: Generate Payment Links with Custom Add-on Quantities

Step 5: Test Your Implementation

Troubleshooting

Congratulations! You’ve Implemented Seat-Based Pricing