Outseta supports usage-based (metered) pricing models that charge customers based on their actual consumption. This flexible approach is ideal for businesses with variable usage patterns, such as API calls, storage, processing time, data transfer, coaching calls, or gym sessions.

Usage-based products must be set up as add-on products connected to one or multiple plans. The plans can be either free, following a pure pay-as-you-go model, or paid, combining a flat fee with usage-based billing.

👉 Learn more about add-on products
👉 Learn more about billing and plans

🚀 Jump straight to the automation examples:

Setting up usage-based pricing

  1. Navigate to Billing > Add-ons in your Outseta dashboard and select Add add-on
  2. Configure your new add-on:
    • Add-on Name: Descriptive name (e.g., "API Calls", "Storage GB", "Coaching Calls")
    • Add-on Type: Select Usage
    • Unit of Measure: Name per unit (e.g., "API Call", "GB", "Call")
    • Monthly Rate: Set your per-unit price (e.g., $0.10 per API call, $95 per coaching call)
    • Setup Fee: Charged once, regardless of usage amount

❗ Important: The add-on must be enabled for at least one plan. Learn how in the general article on Add-on products.

Example: Coaching Calls

A coaching call costs $95 per call, with a one-time setup fee of $45.

Unit of Measure: Call
Usage Rate: $95
Setup Fee: $45

Billing Examples:
Month 1: 1 call = (1 × $95) + $45 = $140
Month 2: 4 calls = 4 × $95 = $380

Example: API Calls

An API service charges $0.001 per call with no setup fee.

Unit of Measure: API Call
Usage Rate: $0.001
Setup Fee: $0

Billing Examples:
Month 1: 10,000 calls = 10,000 × $0.001 = $10
Month 2: 25,500 calls = 25,500 × $0.001 = $25.50

Manual usage tracking

While most usage tracking is done programmatically, Outseta also provides a manual interface for adding and viewing usage data in the dashboard:

  1. Navigate to the customer's account in your Outseta dashboard
  2. Find the History section and choose the Usage tab
  3. Select Add usage and fill in the required fields:
    • Usage Date: The date when the usage occurred
    • Usage Type: Select the appropriate add-on from the dropdown
    • Amount: Enter the quantity consumed
  4. Click Save to record the usage

This manual interface is useful for one-time adjustments, corrections, or small-scale operations where API integration isn't necessary, such as tracking individual coaching calls.

Automated usage tracking

For automated usage tracking, you can integrate with Outseta's REST API to send usage data programmatically. The general workflow involves:

  1. Fetch the account with subscription add-on info
    • GET /api/v1/crm/accounts/<account-uid>?fields=Uid,Name,CurrentSubscription.*,CurrentSubscription.SubscriptionAddOns.*,CurrentSubscription.SubscriptionAddOns.AddOn.*
  2. Find the correct add-on subscription uid
    • Loop through CurrentSubscription.SubscriptionAddOns and find the one where AddOn.Uid is your usage plan uid
  3. Add usage to the add-on subscription found

⚠️ Important: The subscription UID is not the same as the add-on UID. The subscription represents the connection between the account and the add-on.

You can integrate with Outseta's API through automation platforms like Make.com or Zapier, or custom code.

Automated usage tracking with Make.com

You can also automate usage tracking using Make.com (formerly Integromat). This approach allows you to connect various triggers from your application to automatically update usage data in Outseta without writing custom code.

Prerequisites: Create a new scenario with your desired trigger (webhook, scheduled trigger, etc.). The following steps assume you have variables for account_uid, usage_add_on_uid, and amount available from your trigger or previous modules.

Step 1: Fetch Account Data

Add the "Make an API Call" module from the Outseta Make.com app. Configure the API call to fetch the account information, including subscription add-on details:

  • Method: GET
  • URL: /v1/crm/accounts/{account_uid}
  • Query Parameters: fields=Uid,Name,CurrentSubscription.*,CurrentSubscription.SubscriptionAddOns.*,CurrentSubscription.SubscriptionAddOns.AddOn.*

Step 2: Find the correct add-on subscription UID

Use Make.com's Iterator module to loop through the subscription add-ons array. The Iterator will process each add-on subscription in the CurrentSubscription.SubscriptionAddOns[] array.

After the Iterator, add a Filter module to identify the correct add-on subscription. Configure the filter to check that the AddOn: Uid contains your specific usage add-on UID (e.g., "usage_add_on_uid") and that it's a usage-based add-on (BillingAddOnType = 2). This ensures only the correct add-on proceeds to the next step.

Step 3: Submit Usage Data

Finally, configure another Outseta API call to submit the usage data:

  • Method: POST
  • URL: /v1/billing/usage
  • Body: JSON payload containing UsageDate, Amount, and SubscriptionAddOn UID

The request body should include:

{
  "UsageDate": "{{now}}",
  "Amount": {{amount}},
  "SubscriptionAddOn": {
    "Uid": "{{SubscriptionAddOn.Uid}}"
  }
}

This Make.com scenario can be triggered by webhooks, scheduled runs, or other automation triggers based on your application's needs, providing a no-code solution for automating usage-based billing.

Automated usage tracking with Custom Code

The JavaScript function below provides a complete example of how to update usage data programmatically via the  API. This code can be integrated into your application to track and automatically submit usage amounts as they occur for real-time tracking, or as a scheduled job for batch tracking.

💡 Tip: Clone our Outseta API Demos repo for ready-to-use code examples and easy implementation.

/**
 * Updates usage for a specific add-on in Outseta
 * @param {string} accountUid - The unique identifier for the account
 * @param {string} addOnUid - The unique identifier for the add-on
 * @param {number} amount - The usage amount to add
 * @returns {Promise<Object>} - The API response
 */
async function updateUsageBasedPricing(accountUid, addOnUid, amount) {
  try {
    // Step 1: Fetch the account with subscription add-on info
    const accountResponse = await fetch(
      `https://${process.env.OUTSETA_SUBDOMAIN}.outseta.com/api/v1/crm/accounts/${accountUid}?fields=Uid,Name,CurrentSubscription.*,CurrentSubscription.SubscriptionAddOns.*,CurrentSubscription.SubscriptionAddOns.AddOn.*`,
      {
        method: "GET",
        headers: {
          Authorization: `Outseta [your-api-key]:[your-api-secret]`,
          "Content-Type": "application/json",
        },
      }
    );

    if (!accountResponse.ok) {
      throw new Error(`Failed to fetch account: ${accountResponse.status}`);
    }

    const accountData = await accountResponse.json();
    console.log("✅ Account data fetched for:", accountUid);

    // Step 2: Find the correct add-on subscription
    const addOnSubscriptions =
      accountData.CurrentSubscription.SubscriptionAddOns || [];
    const targetAddOnSubscription = addOnSubscriptions.find(
      (subscriptionAddOn) => {
        return subscriptionAddOn.AddOn.Uid === addOnUid;
      }
    );

    // Check if the add-on is found
    if (!targetAddOnSubscription) {
      throw new Error(
        `Subscription for add-on with UID ${addOnUid} not found for account ${accountUid}`
      );
    }

    // Check if the add-on is a usage add-on (BillingAddOnType 2)
    if (targetAddOnSubscription.AddOn.BillingAddOnType !== 2) {
      throw new Error(
        `Add-on with UID ${addOnUid} is not a usage add-on for account ${accountUid}`
      );
    }

    console.log("✅ Found add-on subscription:", targetAddOnSubscription.Uid);

    // Step 3: Update usage for the add-on subscription
    const usageUpdatePayload = {
      UsageDate: new Date().toISOString(),
      Amount: amount,
      SubscriptionAddOn: {
        Uid: targetAddOnSubscription.Uid,
      },
    };

    const usageResponse = await fetch(
      `https://${process.env.OUTSETA_SUBDOMAIN}.outseta.com/api/v1/billing/usage`,
      {
        method: "POST",
        headers: {
          Authorization: `Outseta ${process.env.OUTSETA_API_KEY}:${process.env.OUTSETA_API_SECRET}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify(usageUpdatePayload),
      }
    );

    if (!usageResponse.ok) {
      throw new Error(`Failed to update usage: ${usageResponse.status}`);
    }

    const usageData = await usageResponse.json();
    console.log("✅ Usage updated successfully:", usageData.Uid);
    return usageData;
  } catch (error) {
    console.error("❌ Error updating usage-based pricing:", error.message);
    throw error;
  }
}

// Example usage:
// Update usage for a specific add-on
await updateUsageBasedPricing(
  "<an-account-uid>",
  "<the-usage-add-on-uid>", 
  5 // Add 5 units of usage
)