Clone Algolia pricing

In this article, you will learn how to build a ‘pay-as-you-go’ billing system. This template is suitable for companies whose pricing fully depends on usage, such as cloud service providers and API companies, that only charge their customers for the resources they consume.

Pricing structure

For one of its products, Algolia Search, the platform offers its customers to subscribe for free and only pay based on usage.

Model	Search API
Monthly price	$1.50 / 1,000 requests
Free usage (each month)	10,000 requests

Although users don’t need to subscribe to access the platform, Algolia offers its customers discounts based on volume and commitment (rates available upon request).

Get started

Set up Lago

LAGO_URL="https://api.getlago.com"
API_KEY="__API_KEY__"

from lago_python_client.client import Client
from lago_python_client.exceptions import LagoApiError

client = Client(api_key='__API_KEY__')

require 'lago-ruby-client'

client = Lago::Api::Client.new(api_key: '__API_KEY__')

import { Client } from 'lago-javascript-client';

const client = Client('__API_KEY__');

package main

import (
    "context"
    lago "github.com/getlago/lago-go-client"
)

client := lago.New().SetApiKey("__API_KEY__")

ctx := context.TODO()

Create billable metrics

Create billable metrics to track request usage for Search and Recommend APIs.

Set the aggregation_type to sum_agg to sum all request volumes
Set the field_name to search_requests_volume for Search API tracking
Set the recurring to false for metered billing

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": "Search API Requests",
      "code": "__BILLABLE_METRIC_CODE__",
      "description": "Search API request volume",
      "aggregation_type": "sum_agg",
      "field_name": "search_requests_volume",
      "recurring": false
    }
  }'

from lago_python_client.models import BillableMetric

billable_metric = BillableMetric(
  name='Search API Requests',
  code='__BILLABLE_METRIC_CODE__',
  description='Search API request volume',
  aggregation_type='sum_agg',
  field_name='search_requests_volume',
  recurring=False,
)

client.billable_metrics.create(billable_metric)

client.billable_metrics.create({
  name: 'Search API Requests',
  code: '__BILLABLE_METRIC_CODE__',
  description: 'Search API request volume',
  aggregation_type: 'sum_agg',
  field_name: 'search_requests_volume',
  recurring: false
})

const billable_metric = {
  name: 'Search API Requests',
  code: '__BILLABLE_METRIC_CODE__',
  description: 'Search API request volume',
  aggregationType: 'sum_agg', 
  fieldName: 'search_requests_volume',
  recurring: false
};

await client.billableMetrics.create({ billable_metric })

billableMetricInput := &lago.BillableMetricInput{
  Name:           "Search API Requests",
  Code:           "__BILLABLE_METRIC_CODE__",
  Description:    "Search API request volume",
  AggregationType: "sum_agg",
  FieldName:       "search_requests_volume",
  Recurring:       false,
}

billableMetric, err := client.BillableMetric().Create(ctx, billableMetricInput)

Create a plan

Create a plan to price packages of requests used.

Set the amount_cents to 0 since there is no subscription fee
Set the charges to use package pricing model with Algolia’s rates
Configure free_units of 10,000 requests per month included

curl --location --request POST "$LAGO_URL/api/v1/plans" \
  --header 'Authorization: Bearer __API_KEY__' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "plan": {
      "name": "Algolia Search",
      "code": "__PLAN_CODE__",
      "interval": "monthly",
      "description": "Pay-as-you-go pricing for Algolia Search API",
      "amount_cents": 0,
      "amount_currency": "USD",
      "pay_in_advance": false,
      "charges": [
        {
          "billable_metric_id": "__BILLABLE_METRIC_ID__",
          "charge_model": "package",
          "properties": {
            "amount": "1.50",
            "free_units": 10000,
            "package_size": 1000
          }
        }
      ]
    }
  }'

from lago_python_client.models import Plan, Charge

charge = Charge(
  billable_metric_id='__BILLABLE_METRIC_ID__',
  charge_model='package',
  properties={
    'amount': '1.50',
    'free_units': 10000,
    'package_size': 1000
  }
)

plan = Plan(
  name='Algolia Search PAYG',
  code='__PLAN_CODE__',
  interval='monthly',
  description='Pay-as-you-go pricing for Search API',
  amount_cents=0,
  amount_currency='USD',
  pay_in_advance=False,
  charges=[charge]
)

client.plans.create(plan)

client.plans.create({
  name: 'Algolia Search PAYG',
  code: '__PLAN_CODE__',
  interval: 'monthly',
  description: 'Pay-as-you-go pricing for Search API',
  amount_cents: 0,
  amount_currency: 'USD',
  pay_in_advance: false,
  charges: [
    {
      billable_metric_id: '__BILLABLE_METRIC_ID__',
      charge_model: 'package',
      properties: {
        amount: '1.50',
        free_units: 10000,
        package_size: 1000
      }
    }
  ]
})

const plan = {
  name: 'Algolia Search PAYG',
  code: '__PLAN_CODE__',
  interval: 'monthly',
  description: 'Pay-as-you-go pricing for Search API',
  amount_cents: 0,
  amount_currency: 'USD',
  pay_in_advance: false,
  charges: [
    {
      billable_metric_id: '__BILLABLE_METRIC_ID__',
      charge_model: 'package',
      properties: {
        amount: '1.50',
        free_units: 10000,
        package_size: 1000
      }
    }
  ]
};

await client.plans.createPlan({ plan })

planInput := &lago.PlanInput{
  Name:           "Algolia Search PAYG",
  Code:           "__PLAN_CODE__",
  Interval:       "monthly",
  Description:    "Pay-as-you-go pricing for Search API",
  AmountCents:    0,
  AmountCurrency: "USD",
  PayInAdvance:   false,
  Charges: []*lago.PlanChargeInput{
    {
      BillableMetricID: "__BILLABLE_METRIC_ID__",
      ChargeModel:        "package",
      Properties: map[string]interface{}{
        "amount":       "1.50",
        "free_units":   10000,
        "package_size": 1000,
      },
    },
  },
}

plan, err := client.Plan().Create(ctx, planInput)

Refer to the API reference and guide on package charges to learn more.

Create a customer

Create a customer with a unique external_id.

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"
    }
  }'

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)

client.customers.create(
  external_id: "__EXTERNAL_CUSTOMER_ID__",
  name: "Acme Inc", 
  email: "john@acme.com",
  currency: "USD",
  timezone: "America/New_York"
)

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 });

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 to create a customer.

Create a subscription

Create a subscription for the customer with the plan’s code.

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__"
    }
  }'

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)

client.subscriptions.create(
  external_customer_id: "__EXTERNAL_CUSTOMER_ID__",
  plan_code: "__PLAN_CODE__",
  external_id: "__EXTERNAL_SUBSCRIPTION_ID__"
)

const subscription = {
  external_customer_id: "__EXTERNAL_CUSTOMER_ID__",
  plan_code: "__PLAN_CODE__",
  external_id: "__EXTERNAL_SUBSCRIPTION_ID__"
};

await client.subscriptions.createSubscription({ subscription });

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 to create a subscription.

Ingest usage via events

Send usage events to Lago to track API requests.

Set the code to match your billable metric code
Include search_requests_volume property with the number of requests

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": {
        "search_requests_volume": 5000
      }
    }
  }'

from lago_python_client.models import Event

event = Event(
  transaction_id="__TRANSACTION_ID__",
  code="__BILLABLE_METRIC_CODE__",
  external_subscription_id="__EXTERNAL_SUBSCRIPTION_ID__",
  properties={
    "search_requests_volume": 5000
  }
)

client.events.create(event)

client.events.create(
  transaction_id: "__TRANSACTION_ID__",
  code: "__BILLABLE_METRIC_CODE__",
  external_subscription_id: "__EXTERNAL_SUBSCRIPTION_ID__",
  properties: {
    search_requests_volume: 5000
  }
)

const event = {
  transaction_id: "__TRANSACTION_ID__",
  code: "__BILLABLE_METRIC_CODE__",
  external_subscription_id: "__EXTERNAL_SUBSCRIPTION_ID__",
  properties: {
    search_requests_volume: 5000
  }
};

await client.events.createEvent({ event });

eventInput := &lago.EventInput{
  TransactionID:          "__TRANSACTION_ID__",
  Code:                   "__BILLABLE_METRIC_CODE__",
  ExternalSubscriptionID: "__EXTERNAL_SUBSCRIPTION_ID__",
  Properties: map[string]interface{}{
    "search_requests_volume": 5000,
  },
}

event, err := client.Event().Create(ctx, eventInput)

Refer to the API reference to create an event.

Monitor current usage

Track real-time customer usage for the current billing period.

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'

customer_usage = client.customers.current_usage('__EXTERNAL_CUSTOMER_ID__', '__EXTERNAL_SUBSCRIPTION_ID__')

customer_usage = client.customer.current_usage('__EXTERNAL_CUSTOMER_ID__', '__EXTERNAL_SUBSCRIPTION_ID__')

const customerUsage = await client.customers.findCustomerCurrentUsage(
    '__EXTERNAL_CUSTOMER_ID__',
    { external_subscription_id: '__EXTERNAL_SUBSCRIPTION_ID__' }
)

customerUsage, err := client.Customer().CurrentUsage(ctx, "__EXTERNAL_CUSTOMER_ID__")

Refer to the API reference to get the current usage.

Wrap-up

‘Pay-as-you-go’ pricing strategies are popular among API companies like Algolia. With Lago, you can adapt this template to your products and services, using some of our most popular features:

Plan models, with or without subscription;‍
Billable metrics, including the ‘sum’ aggregation type; and‍
Charges, including our package and graduated pricing models.

Give it a try, click here to get started!

Templates

Per-token pricing

Hybrid pricing

Per-transaction pricing

Pay-as-you-go pricing

Per-seat pricing

Clone Algolia pricing

Pricing structure

Get started

Wrap-up

​Pricing structure

​Get started

​Wrap-up

Pricing structure

Get started

Wrap-up