Creating Products

Learn about products in Autumn and how to create them

Products are the separate packages that define what your customers get and how much they should be billed for it. Each product you create is a distinct combination of these features and prices.

For example, you can define a separate product for all the pricing tiers (eg free plan, team plan, enterprise tier) you offer, or all your different price variations (annual billing, monthly billing, usage-based billing)

Creating a product

Navigate to products section and click create product

1. Fill in a name. This will be used to create a product in Stripe and show up on your checkout pages.
2. Fill in an ID. You’ll use this when using Autumn’s APIs or SDKs to refer to this product.
3. Click “Create Product”. You’ll be taken to the product editing page.

You also have the option to duplicate a product. You can choose whether to copy it into Sandbox or the live environment. Hit the Elipses menu on the right of the product table and select “Copy”.

Once the product is created, you’ll be taken to the product editing page. Here you can add product items, as well as set the properties of the product.

Product items

Products are made up of product items. These can be:

• Features - define the features that your customers get access to with this product
• Prices - how much customers should pay for this tier. These can be one off prices or subscriptions
• Feature Prices - for charging based on usage of a feature, you can add both a feature and price together

Product Properties

Default Product

Set this is the product should be automatically applied to a customer when they’re created. This is typically for free products that give customers access to a limited set of features without paying.

If you set a product to be default, and it has a price, Autumn will still apply it to the customer. However, since there are no payment details for the customer by default, Autumn will send an invoice the customer’s email.

Add on Product

Set this if the product is an add on. This will mean it can be purchased together with other products

Product Groups

If you have multiple groups of subscriptions, and customers can have a product from each of these subscription groups live at the same time, use this field. All product tiers from the same group should have the same value.

Example

Let’s say you have two different types of chatbots - one for customer support and one for sales. You want customers to be able to have both types of chatbots at the same time, but only one tier from each type.

You would create two product groups:

1. “Customer Support Chatbots” (group: “support”)

   • Basic ($49/month - 1,000 tickets)
   • Advanced ($149/month - 5,000 tickets)
   • Enterprise ($399/month - Unlimited tickets)

2. “Sales Chatbots” (group: “sales”)

   • Starter ($79/month - 500 leads)
   • Growth ($199/month - 2,000 leads)
   • Enterprise ($499/month - Unlimited leads)

This way, a customer could have both the “Advanced Support” chatbot and the “Starter Sales” chatbot active at the same time, but they couldn’t have both “Basic Support” and “Advanced Support” active together.

Free Trials

You can set a free trial for a product with prices. This will give customers a set amount of days to try the product for free.

To enable a free trial:

1. Go to the product page
2. In the sidebar, you’ll see a “Free Trials” section. Click on the + icon to add a new free trial
3. In the popup, fill in the how many days the trial should last.
4. Click “Update Product”

If you’re using the customer fingerprint field, you can also choose to limit the free trial to one per customer.

Using the CLI

The schema for our product and feature builders follows the same schema as our API.

Example autumn.config.ts

autumn.config.ts

import {
	feature,
	product,
	featureItem,
	pricedFeatureItem,
	priceItem,
} from 'atmn';


// Features
export const canUseTokens = feature({
id: 'can_use_tokens',
name: 'Can Use Tokens',
type: 'boolean',
})

export const message = feature({
  id: "message",
  name: "Messages",
  type: "metered",
});

export const taskRuns = feature({
  id: "task_runs",
  name: "Task Runs",
  type: "metered",
});

// Products
export const freePlan = product({
id: 'free',
name: 'Free',
items: [
featureItem({
feature_id: message.id,
included_usage: 200,
interval: 'month',
}),
]
})

export const ultraPlan = product({
  id: "ultra",
  name: "Ultra",
  items: [
    priceItem({
      price: 300,
      interval: "year",
    }),

    pricedFeatureItem({
      feature_id: message.id,
      price: 200,
      interval: "month",
      included_usage: 80,
      billing_units: 100,
      usage_model: "pay_per_use",
    }),

    featureItem({
      feature_id: message.id,
      included_usage: 900,
      interval: "year",
    }),

    featureItem({
      feature_id: taskRuns.id,
      included_usage: 900,
      interval: "year",
    }),
  ],
});

export const proPlan = product({
  id: "pro",
  name: "Pro",
  items: [
    priceItem({
      price: 200,
      interval: "year",
    }),

    pricedFeatureItem({
      feature_id: canUseTokens.id,
      price: 200,
      interval: "month",
      included_usage: 1,
      billing_units: 1,
      usage_model: "prepaid",
    }),

    pricedFeatureItem({
      feature_id: message.id,
      price: 200,
      interval: "month",
      included_usage: 30,
      billing_units: 100,
      usage_model: "pay_per_use",
    }),

    featureItem({
      feature_id: message.id,
      included_usage: 650,
      interval: "year",
    }),

    featureItem({
      feature_id: taskRuns.id,
      included_usage: 650,
      interval: "year",
    }),
  ],
});

// Remember to update this when you make changes!
export default {
products: [freePlan, ultraPlan, proPlan],
features: [canUseTokens, message, taskRuns]
}

First, run npx atmn auth to authenticate yourself with the CLI.

Then run npx atmn push to push your changes to Autumn’s sandbox environment.