Subscription plan changes are a crucial aspect of managing customer relationships and driving revenue growth. Whether your customers are scaling up their usage or need to temporarily reduce their plan, Outseta provides flexible options for handling both upgrades and downgrades seamlessly.

This guide covers everything you need to know about subscription changes in Outseta, from simple manual adjustments through your dashboard to fully automated workflows using APIs and third-party automation tools. You'll learn how to handle the nuances of proration, timing, and customer communication to ensure smooth transitions that keep your customers happy.

Upgrades

In the case of an upgrade, the user's plan changes immediately, and Outseta will automatically handle any proration of subscription fees.

Whether you're upgrading the customer manually or the customer is upgrading on their own, a summary of charges showing the proration will always display before the change is made.

Downgrades

In the case of a downgrade, the plan change will take effect immediately, provided it does not result in you owing the customer money.

If the change would result in you owing the customer money, the user will continue to have access to the higher tiered plan that they already paid for until the end of their existing subscription period. Once that period has ended, the user's subscription will change to the lower-tiered plan.

Example: Consider a customer downgrading from a $ 1,000/month plan to a $500/month plan. If the customer tried to make this change in the first half of the month, the money that they would be owed would be more than the $500/month of their new plan—in this case the user would remain subscribed to the $1000/mo plan until the end of the month, at which point they'd be downgraded to the $500/mo plan.

If the user attempts to downgrade in the second half of the month, the amount they would be owed would be less than the new $500 monthly plan. The change will take effect immediately.

In short, Outseta will not allow a customer to put themselves in a position where they owe you money.

Downgrade an account, effective immediately

If you'd like to downgrade an account but have the subscription change take effect immediately—even if this would result in you owing the customer money—you can make that change as an admin user. To do so, select the 'Start immediately' option when changing the subscription.

You can then refund the customer any amount that you see fit.

Manual upgrades/downgrades

The simplest way to change an account's plan is through the Outseta dashboard interface. This method is perfect for customer service teams or account managers who need to make quick plan changes without technical implementation. Customer may also change their subscription via the Outseta profile embed.

Outseta dashboard

  1. Navigate to CRM > Accounts in your Outseta dashboard
  2. Find and open the account you want to modify
  3. Locate the Subscription section on the account page
  4. Click the "Options" dropdown next to the subscription details
  5. Select "Change subscription" from the menu
  6. Follow the wizard to select the new plan, billing term, and review charges

Self-Service

Users can also upgrade or downgrade their subscription through Outseta's self-serve profile embed. The profile embed provides an intuitive interface for customers to manage their subscription changes while respecting the same upgrade and downgrade logic.

ℹ️ Note: The "Start Immediately" override is not available to end users. It can only be accessed through the Outseta dashboard or Admin API.

Automated Upgrades/Downgrades

For workflows that require automation, bulk operations, or custom integrations, you can programmatically change subscription plans. This section covers two approaches: using Make (Integromat) for no-code automation and custom server-side code for maximum flexibility.

General Process

All automated subscription changes follow the same basic process:

Step 1: Find Current Subscription

First, retrieve the account's current subscription details using the Account ID (or email). This provides the subscription UID needed for the update and validates that the account has an active subscription.

Step 2: Change Subscription

Once you have the current subscription information, update it with the new plan details. This includes specifying the new plan UID, billing renewal term, and whether the change should take effect immediately.

Automated Upgrades/Downgrades with Make (Zapier Alternative)

Make provides a visual, no-code approach to automating subscription changes based on triggers from other applications in your workflow. This method is ideal for teams that want automation without custom development.

Prerequisites

  • Outseta App configured in Make with your account credentials
  • A trigger that provides the Account ID of the customer whose plan you want to change
  • New Plan ID for the target subscription plan

This trigger could be a webhook, a manual trigger, or data from another service in your workflow.

Step 1: Outseta > Get Account

  • Add the "Get Account" Outseta module to your scenario
  • Configure the connection with your Outseta credentials
  • Set the Account ID (can be from trigger data or manually specified)

Step 2: Outseta > Make API Call

  • Add the "Make an API Call" module from the Outseta App
  • Set the URL to: /billing/subscriptions/{{3.CurrentSubscription.Uid}}/changesubscription
  • Configure method: PUT to update existing subscriptions
  • Configure headers: Content-Type: application/json
  • You may also add startImmidatlyas a query param to control timing
  • Set up the body with subscription update data:
{
  "Account": { "Uid": "{{3.Uid}}" },
  "Plan": { "Uid": "{{1.PlanUid}}" },
  "BillingRenewalTerm": "{{3.CurrentSubscription.BillingRenewalTerm}}"
}

Automated Upgrades/Downgrades with Custom Code

For automated workflows, bulk operations, or custom integrations, you can programmatically change subscription plans using Outseta's REST API. This method requires server-side implementation, offering greater flexibility and automation capabilities.

Prerequisites

Before using the API, you'll need:

  • API Key and Secret from Settings > Integrations > API Keys
  • Account Uid of the customer
  • Plan Uid of the target plan
  • Server-side environment (Node.js, Python, etc.)

Server-Side Implementation

Below is a complete server-side function to change subscription plans. For a complete working demo with preview functionality, see the Change Plan Demo.

/**
 * Changes the subscription plan for an account in Outseta
 * @param {Object}  options - The options object
 * @param {string}  options.accountUid - The unique identifier for the account
 * @param {string}  options.newPlanUid - The unique identifier for the new plan to change to
 * @param {boolean} options.startImmediately=false - Whether the changes should start immediately
 * @returns {Promise<Object>} - The API response
 */
export async function changePlan({
  accountUid,
  newPlanUid,
  startImmediately = false,
}) {
  // Step 1: Fetch the account with current subscription info
  const accountResponse = await fetch(
    `https://[your-subdomain].outseta.com/api/v1/crm/accounts/${accountUid}?fields=Uid,Name,CurrentSubscription.*`,
    {
      method: "GET",
      headers: {
        Authorization: `Outseta [your-api-key]:[your-secret-key]`,
        "Content-Type": "application/json",
      },
    }
  );

  const accountData = await accountResponse.json();
  if (!accountResponse.ok) {
    throw new Error(
      `/api/v1/crm/accounts/${accountUid}: [${accountResponse.status}] ${
        accountData.ErrorMessage || accountData.Message || ""
      }`
    );
  }

  console.debug(`✅ Account data fetched for: ${accountUid}`);

  // Step 2: Validate that the account has a current subscription
  if (!accountData.CurrentSubscription) {
    throw new Error(
      `Account ${accountUid} does not have an active subscription`
    );
  }

  const currentSubscription = accountData.CurrentSubscription;
  console.debug(`✅ Found current subscription: ${currentSubscription.Uid}`);

  // Step 3: Update the subscription with the new plan
  const subscriptionUpdatePayload = {
    Plan: {
      Uid: newPlanUid,
    },
    BillingRenewalTerm: currentSubscription.BillingRenewalTerm,
    Account: {
      Uid: accountUid,
    },
  };

  const subscriptionResponse = await fetch(
    `https://[your-subdomain].outseta.com/api/v1/billing/subscriptions/${currentSubscription.Uid}/changeSubscription?startImmediately=${startImmediately}`,
    {
      method: "PUT",
      headers: {
        Authorization: `Outseta [your-api-key]:[your-secret-key]`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(subscriptionUpdatePayload),
    }
  );

  const subscriptionData = await subscriptionResponse.json();
  const endpoint = `/api/v1/billing/subscriptions/${currentSubscription.Uid}/changeSubscription`;
  console.debug(`\n--- ${endpoint} response ---`);
  console.debug(JSON.stringify(subscriptionData, null, 2));
  console.debug("------------------------------\n");

  if (!subscriptionResponse.ok) {
    throw new Error(
      `${endpoint}: [${subscriptionResponse.status}] ${
        subscriptionData.ErrorMessage || subscriptionData.Message || ""
      }`
    );
  }

  return subscriptionData;
}

Usage Example

Here's how to use the function to change a customer's plan:

// Example usage
try {
  const result = await changePlan({
    accountUid: "customer-account-uid",
    newPlanUid: "new-plan-uid",
    startImmediately: false // Set to true for immediate downgrades
  });
  
  console.log("Plan changed successfully:", result);
} catch (error) {
  console.error("Failed to change plan:", error.message);
}