> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getlago.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Clone Segment pricing
> Replicate Segment's hybrid pricing model with Lago.
Build a hybrid pricing and billing system like [Segment](https://segment.com/), the Customer Data Platform leader, based on subscription plans, with a usage-based component that makes your revenue grow with your users.
## Pricing structure
Segment offers three pricing plans, called 'Free', 'Team' and 'Business'. As the latter has a custom pricing, we will focus on the first two plans.
| Plan | Free plan | Team plan |
| --------------------------- | ---------- | ----------------- |
| Subscription Fee | \$0/month | \$120/month |
| Base Consumption (included) | 1,000 MTUs | 10,000 MTUs |
| Consumption (10k-25k MTUs) | n/a | \$0.012/month/MTU |
| Consumption (25k-100k MTUs) | n/a | \$0.011/month/MTU |
| Consumption (100k+ MTUs) | n/a | \$0.010/month/MTU |
| Trial Period | n/a | 14 days |
The usage-based component in Segment's pricing is related to **monthly tracked users (MTUs)**, namely the number of unique users whose data is stored on the platform each month.
## Get started
```bash cURL theme={"dark"}
LAGO_URL="https://api.getlago.com"
API_KEY="__API_KEY__"
```
```python Python theme={"dark"}
from lago_python_client.client import Client
from lago_python_client.exceptions import LagoApiError
client = Client(api_key='__API_KEY__')
```
```ruby Ruby theme={"dark"}
require 'lago-ruby-client'
client = Lago::Api::Client.new(api_key: '__API_KEY__')
```
```javascript Javascript theme={"dark"}
import { Client } from 'lago-javascript-client';
const client = Client('__API_KEY__');
```
```go Go theme={"dark"}
package main
import (
"context"
lago "github.com/getlago/lago-go-client"
)
client := lago.New().SetApiKey("__API_KEY__")
ctx := context.TODO()
```
Create a billable metric to track unique users with deduplication.
1. Set the `aggregation_type` to `unique_count_agg` for counting unique users
2. Set the `field_name` to `user_id` to identify individual users
3. Set `recurring` to `false` for metered billing
```bash cURL highlight={7,9-11} theme={"dark"}
curl --location --request POST "$LAGO_URL/api/v1/billable_metrics" \
--header 'Authorization: Bearer __API_KEY__' \
--header 'Content-Type: application/json' \
--data-raw '{
"billable_metric": {
"name": "Monthly Tracked Users",
"code": "__BILLABLE_METRIC_CODE__",
"description": "Unique users tracked monthly",
"aggregation_type": "unique_count_agg",
"field_name": "user_id",
"recurring": false
}
}'
```
```python Python highlight={5,7-9,12} theme={"dark"}
from lago_python_client.models import BillableMetric
billable_metric = BillableMetric(
name='Monthly Tracked Users',
code='__BILLABLE_METRIC_CODE__',
description='Unique users tracked monthly',
aggregation_type='unique_count_agg',
field_name='user_id',
recurring=False
)
client.billable_metrics.create(billable_metric)
```
```ruby Ruby highlight={3,5-7} theme={"dark"}
client.billable_metrics.create({
name: 'Monthly Tracked Users',
code: '__BILLABLE_METRIC_CODE__',
description: 'Unique users tracked monthly',
aggregation_type: 'unique_count_agg',
field_name: 'user_id',
recurring: false
})
```
```javascript JavaScript highlight={3,5-7,10} theme={"dark"}
const billableMetric = {
name: 'Monthly Tracked Users',
code: '__BILLABLE_METRIC_CODE__',
description: 'Unique users tracked monthly',
aggregation_type: 'unique_count_agg',
field_name: 'user_id',
recurring: false
};
await client.billableMetrics.createBillableMetric({ billableMetric });
```
```go Go highlight={3,5-7,10} theme={"dark"}
billableMetricInput := &lago.BillableMetricInput{
Name: "Monthly Tracked Users",
Code: "__BILLABLE_METRIC_CODE__",
Description: "Unique users tracked monthly",
AggregationType: "unique_count_agg",
FieldName: "user_id",
Recurring: false,
}
billableMetric, err := client.BillableMetric().Create(ctx, billableMetricInput)
```
Create a Team plan with subscription fee and graduated usage charges.
1. Set the `amount_cents` to `12000` for \$120 monthly subscription
2. Set `pay_in_advance` to `true` for upfront payment
3. Set `trial_period` to `14` days for the trial period
4. Configure `graduated_ranges` with Segment's tiered pricing structure
```bash cURL expandable highlight={7,10-47} theme={"dark"}
curl --location --request POST "$LAGO_URL/api/v1/plans" \
--header 'Authorization: Bearer __API_KEY__' \
--header 'Content-Type: application/json' \
--data-raw '{
"plan": {
"name": "Segment Team Plan",
"code": "__PLAN_CODE__",
"interval": "monthly",
"description": "Team plan with subscription and graduated usage",
"amount_cents": 12000,
"amount_currency": "USD",
"pay_in_advance": true,
"trial_period": 14,
"charges": [
{
"billable_metric_id": "__BILLABLE_METRIC_ID__",
"charge_model": "graduated",
"properties": {
"graduated_ranges": [
{
"from_value": 0,
"to_value": 10000,
"flat_amount": "0",
"per_unit_amount": "0"
},
{
"from_value": 10001,
"to_value": 25000,
"flat_amount": "0",
"per_unit_amount": "0.012"
},
{
"from_value": 25001,
"to_value": 100000,
"flat_amount": "0",
"per_unit_amount": "0.011"
},
{
"from_value": 100001,
"to_value": null,
"flat_amount": "0",
"per_unit_amount": "0.010"
}
]
}
}
]
}
}'
```
```python Python expandable highlight={3-34,38,41,43-45,48} theme={"dark"}
from lago_python_client.models import Plan, Charge
charge = Charge(
billable_metric_id='__BILLABLE_METRIC_ID__',
charge_model='graduated',
properties={
'graduated_ranges': [
{
'from_value': 0,
'to_value': 10000,
'flat_amount': '0',
'per_unit_amount': '0'
},
{
'from_value': 10001,
'to_value': 25000,
'flat_amount': '0',
'per_unit_amount': '0.012'
},
{
'from_value': 25001,
'to_value': 100000,
'flat_amount': '0',
'per_unit_amount': '0.011'
},
{
'from_value': 100001,
'to_value': None,
'flat_amount': '0',
'per_unit_amount': '0.010'
}
]
}
)
plan = Plan(
name='Segment Team Plan',
code='__PLAN_CODE__',
interval='monthly',
description='Team plan with subscription and graduated usage',
amount_cents=12000,
amount_currency='USD',
pay_in_advance=True,
trial_period=14,
charges=[charge]
)
client.plans.create(plan)
```
```ruby Ruby expandable highlight={3,6,8-43} theme={"dark"}
client.plans.create({
name: 'Segment Team Plan',
code: '__PLAN_CODE__',
interval: 'monthly',
description: 'Team plan with subscription and graduated usage',
amount_cents: 12000,
amount_currency: 'USD',
pay_in_advance: true,
trial_period: 14,
charges: [
{
billable_metric_id: '__BILLABLE_METRIC_ID__',
charge_model: 'graduated',
properties: {
graduated_ranges: [
{
from_value: 0,
to_value: 10000,
flat_amount: '0',
per_unit_amount: '0'
},
{
from_value: 10001,
to_value: 25000,
flat_amount: '0',
per_unit_amount: '0.012'
},
{
from_value: 25001,
to_value: 100000,
flat_amount: '0',
per_unit_amount: '0.011'
},
{
from_value: 100001,
to_value: nil,
flat_amount: '0',
per_unit_amount: '0.010'
}
]
}
}
]
})
```
```javascript JavaScript expandable highlight={3,6,8-43,46} theme={"dark"}
const plan = {
name: 'Segment Team Plan',
code: '__PLAN_CODE__',
interval: 'monthly',
description: 'Team plan with subscription and graduated usage',
amount_cents: 12000,
amount_currency: 'USD',
pay_in_advance: true,
trial_period: 14,
charges: [
{
billable_metric_id: '__BILLABLE_METRIC_ID__',
charge_model: 'graduated',
properties: {
graduated_ranges: [
{
from_value: 0,
to_value: 10000,
flat_amount: '0',
per_unit_amount: '0'
},
{
from_value: 10001,
to_value: 25000,
flat_amount: '0',
per_unit_amount: '0.012'
},
{
from_value: 25001,
to_value: 100000,
flat_amount: '0',
per_unit_amount: '0.011'
},
{
from_value: 100001,
to_value: null,
flat_amount: '0',
per_unit_amount: '0.010'
}
]
}
}
]
};
await client.plans.createPlan({ plan });
```
```go Go expandable highlight={3,6,8-43,46} theme={"dark"}
planInput := &lago.PlanInput{
Name: "Segment Team Plan",
Code: "__PLAN_CODE__",
Interval: "monthly",
Description: "Team plan with subscription and graduated usage",
AmountCents: 12000,
AmountCurrency: "USD",
PayInAdvance: true,
TrialPeriod: 14,
Charges: []*lago.PlanChargeInput{
{
BillableMetricID: "__BILLABLE_METRIC_ID__",
ChargeModel: "graduated",
Properties: map[string]interface{}{
"graduated_ranges": []map[string]interface{}{
{
"from_value": 0,
"to_value": 10000,
"flat_amount": "0",
"per_unit_amount": "0",
},
{
"from_value": 10001,
"to_value": 25000,
"flat_amount": "0",
"per_unit_amount": "0.012",
},
{
"from_value": 25001,
"to_value": 100000,
"flat_amount": "0",
"per_unit_amount": "0.011",
},
{
"from_value": 100001,
"to_value": nil,
"flat_amount": "0",
"per_unit_amount": "0.010",
},
},
},
},
},
}
plan, err := client.Plan().Create(ctx, planInput)
```
Create a customer with a unique `external_id`.
```bash cURL highlight={6} theme={"dark"}
curl --location --request POST "$LAGO_URL/api/v1/customers" \
--header "Authorization: Bearer $API_KEY" \
--header 'Content-Type: application/json' \
--data-raw '{
"customer": {
"external_id": "__EXTERNAL_CUSTOMER_ID__",
"name": "Acme Inc",
"email": "john@acme.com",
"currency": "USD",
"timezone": "America/New_York"
}
}'
```
```python Python highlight={4,11} theme={"dark"}
from lago_python_client.models import Customer
customer = Customer(
external_id="__EXTERNAL_CUSTOMER_ID__",
name="Acme Inc",
email="john@acme.com",
currency="USD",
timezone="America/New_York"
)
client.customers.create(customer)
```
```ruby Ruby highlight={2} theme={"dark"}
client.customers.create(
external_id: "__EXTERNAL_CUSTOMER_ID__",
name: "Acme Inc",
email: "john@acme.com",
currency: "USD",
timezone: "America/New_York"
)
```
```js Javascript highlight={2,9} theme={"dark"}
const customer = {
external_id: "__EXTERNAL_CUSTOMER_ID__",
name: "Acme Inc",
email: "john@acme.com",
currency: "USD",
timezone: "America/New_York"
};
await client.customers.createCustomer({ customer });
```
```go Go highlight={2,9} theme={"dark"}
customerInput := &lago.CustomerInput{
ExternalID: "__EXTERNAL_CUSTOMER_ID__",
Name: "Acme Inc",
Email: "john@acme.com",
Currency: "USD",
Timezone: "America/New_York",
}
customer, err := client.Customer().Create(ctx, customerInput)
```
Refer to the [API reference](/api-reference/customers/create) to create a customer.
Create a subscription for the customer with the plan's `code`.
```bash cURL highlight={6-8} theme={"dark"}
curl --location --request POST "$LAGO_URL/api/v1/subscriptions" \
--header "Authorization: Bearer $API_KEY" \
--header 'Content-Type: application/json' \
--data-raw '{
"subscription": {
"external_customer_id": "__EXTERNAL_CUSTOMER_ID__",
"plan_code": "__PLAN_CODE__",
"external_id": "__EXTERNAL_SUBSCRIPTION_ID__"
}
}'
```
```python Python highlight={4-6,9} theme={"dark"}
from lago_python_client.models import Subscription
subscription = Subscription(
external_customer_id="__EXTERNAL_CUSTOMER_ID__",
plan_code="__PLAN_CODE__",
external_id="__EXTERNAL_SUBSCRIPTION_ID__"
)
client.subscriptions.create(subscription)
```
```ruby Ruby highlight={2-4} theme={"dark"}
client.subscriptions.create(
external_customer_id: "__EXTERNAL_CUSTOMER_ID__",
plan_code: "__PLAN_CODE__",
external_id: "__EXTERNAL_SUBSCRIPTION_ID__"
)
```
```js Javascript highlight={2-4,7} theme={"dark"}
const subscription = {
external_customer_id: "__EXTERNAL_CUSTOMER_ID__",
plan_code: "__PLAN_CODE__",
external_id: "__EXTERNAL_SUBSCRIPTION_ID__"
};
await client.subscriptions.createSubscription({ subscription });
```
```go Go highlight={2-4,7} theme={"dark"}
subscriptionInput := &lago.SubscriptionInput{
ExternalCustomerID: "__EXTERNAL_CUSTOMER_ID__",
PlanCode: "__PLAN_CODE__",
ExternalID: "__EXTERNAL_SUBSCRIPTION_ID__",
}
subscription, err := client.Subscription().Create(ctx, subscriptionInput)
```
Refer to the [API reference](/api-reference/subscriptions/assign-plan) to create a subscription.
Refer to [API reference](/api-reference/subscriptions/assign-plan) and [guide on assigning plans](/guide/subscriptions/assign-plan) in the documentation.
Send usage events to Lago to track usage.
1. Reference your billable metric with `code`
2. Reference the customer's subscription with `external_subscription_id`
3. Include usage and filters data in `properties`
```bash cURL highlight={7-11} theme={"dark"}
curl --location --request POST "$LAGO_URL/api/v1/events" \
--header 'Authorization: Bearer __API_KEY__' \
--header 'Content-Type: application/json' \
--data-raw '{
"event": {
"transaction_id": "__TRANSACTION_ID__",
"code": "__BILLABLE_METRIC_CODE__",
"external_subscription_id": "__EXTERNAL_SUBSCRIPTION_ID__",
"properties": {
"user_id": "user_id_001"
}
}
}'
```
```python Python highlight={5-9,11} theme={"dark"}
from lago_python_client.models import Event
event = Event(
transaction_id='__TRANSACTION_ID__',
code='__BILLABLE_METRIC_CODE__',
external_subscription_id='__EXTERNAL_SUBSCRIPTION_ID__',
properties={
'user_id': 'user_id_001'
}
)
client.events.create(event)
```
```ruby Ruby highlight={3-7} theme={"dark"}
client.events.create({
transaction_id: '__TRANSACTION_ID__',
code: '__BILLABLE_METRIC_CODE__',
external_subscription_id: '__EXTERNAL_SUBSCRIPTION_ID__',
properties: {
user_id: 'user_id_001'
}
})
```
```javascript JavaScript highlight={3-7,10} theme={"dark"}
const event = {
transaction_id: '__TRANSACTION_ID__',
code: '__BILLABLE_METRIC_CODE__',
external_subscription_id: '__EXTERNAL_SUBSCRIPTION_ID__',
properties: {
user_id: 'user_id_001'
}
};
await client.events.createEvent({ event });
```
```go Go highlight={3-7,10} theme={"dark"}
eventInput := &lago.EventInput{
TransactionID: "__TRANSACTION_ID__",
Code: "__BILLABLE_METRIC_CODE__",
ExternalSubscriptionID: "__EXTERNAL_SUBSCRIPTION_ID__",
Properties: map[string]interface{}{
"user_id": "user_id_001",
},
}
event, err := client.Event().Create(ctx, eventInput)
```
Refer to the [API reference](/api-reference/events/usage) to create an event.
Track real-time customer usage for the current billing period.
```bash cURL highlight={1} theme={"dark"}
curl --location --request GET "$LAGO_URL/api/v1/customers/__EXTERNAL_CUSTOMER_ID__/current_usage?external_subscription_id=__EXTERNAL_SUBSCRIPTION_ID__" \
--header 'Authorization: Bearer __API_KEY__' \
--header 'Content-Type: application/json'
```
```python Python highlight={1} theme={"dark"}
customer_usage = client.customers.current_usage('__EXTERNAL_CUSTOMER_ID__', '__EXTERNAL_SUBSCRIPTION_ID__')
```
```ruby Ruby highlight={1} theme={"dark"}
customer_usage = client.customer.current_usage('__EXTERNAL_CUSTOMER_ID__', '__EXTERNAL_SUBSCRIPTION_ID__')
```
```js Javascript highlight={1-4} theme={"dark"}
const customerUsage = await client.customers.findCustomerCurrentUsage(
'__EXTERNAL_CUSTOMER_ID__',
{ external_subscription_id: '__EXTERNAL_SUBSCRIPTION_ID__' }
)
```
```go Go highlight={1} theme={"dark"}
customerUsage, err := client.Customer().CurrentUsage(ctx, "__EXTERNAL_CUSTOMER_ID__")
```
Refer to the [API reference](/api-reference/customer-usage/get-current) to get the current usage.
## Wrap-up
Hybrid pricing plans are very popular among SaaS, API, fintech and data companies like Segment.
With Lago, you can easily adapt this template to create your own hybrid pricing plan, using some of our most popular features:
* **Plan models**, including monthly/yearly plans that can be paid in advance or in arrears;
* **Billable metrics**, including multiple aggregation types; and
* **Charges**, including our graduated pricing model (and more).
Give it a try, click [here](https://www.getlago.com/get-started) to get started!