Clone Google BigQuery pricing

This template shows you how to offer free upfront credits to new users on a ‘pay-as-you-go’ pricing model. It suits infrastructure companies, like this BigQuery example. AI companies also use it widely to let new users try their products. Mistral or Perplexity are other great examples.

Pricing structure

BigQuery offers customers the possibility to subscribe for free and only pay based on usage. For new customers, the platform offers $300 worth of credits during 90 days to try the product completely for free.

Plan	Cost per volume of data scanned
On-Demand pricing	$6.25 per TiB (a tebibyte of data scanned)

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 a billable metric

Create a billable metric to track data processing volume.

Set the aggregation_type to sum_agg to sum all data processed
Set the field_name to data_processed_volume for tracking usage
Set 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": "BigQuery Data Processing",
      "code": "__BILLABLE_METRIC_CODE__",
      "description": "Data processing volume in TiB",
      "aggregation_type": "sum_agg",
      "field_name": "data_processed_volume",
      "recurring": false
    }
  }'

from lago_python_client.models import BillableMetric

billable_metric = BillableMetric(
  name='BigQuery Data Processing',
  code='__BILLABLE_METRIC_CODE__',
  description='Data processing volume in TiB',
  aggregation_type='sum_agg',
  field_name='data_processed_volume',
  recurring=False
)

client.billable_metrics.create(billable_metric)

client.billable_metrics.create({
  name: 'BigQuery Data Processing',
  code: '__BILLABLE_METRIC_CODE__',
  description: 'Data processing volume in TiB',
  aggregation_type: 'sum_agg',
  field_name: 'data_processed_volume',
  recurring: false
})

const billableMetric = {
  name: 'BigQuery Data Processing',
  code: '__BILLABLE_METRIC_CODE__',
  description: 'Data processing volume in TiB',
  aggregation_type: 'sum_agg',
  field_name: 'data_processed_volume',
  recurring: false
};

await client.billableMetrics.createBillableMetric({ billable_metric: billableMetric })

billableMetricInput := &lago.BillableMetricInput{
  Name:             "BigQuery Data Processing",
  Code:             "__BILLABLE_METRIC_CODE__",
  Description:      "Data processing volume in TiB",
  AggregationType:  "sum_agg",
  FieldName:        "data_processed_volume",
  Recurring:        false,
}

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

Refer to the API reference to create a billable metric.

Create a plan

Create a plan with graduated pricing to include free tier usage.

Set the amount_cents to 0 since there is no subscription fee
Use graduated charge model with BigQuery’s $6.25 per TiB rate
Configure first 10 TiB as free, then $6.25 per TiB after that

curl --location --request POST "$LAGO_URL/api/v1/plans" \
  --header "Authorization: Bearer $API_KEY" \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "plan": {
      "name": "BigQuery On-Demand",
      "code": "__PLAN_CODE__",
      "interval": "monthly",
      "description": "Pay-as-you-go BigQuery pricing with free tier",
      "amount_cents": 0,
      "amount_currency": "USD",
      "pay_in_advance": false,
      "charges": [
        {
          "billable_metric_id": "__BILLABLE_METRIC_ID__",
          "charge_model": "graduated",
          "properties": {
            "graduated_ranges": [
              {
                "from_value": 0,
                "to_value": 10000,
                "per_unit_amount": "0",
                "flat_amount": "0"
              },
              {
                "from_value": 10001,
                "to_value": null,
                "per_unit_amount": "6.25",
                "flat_amount": "0"
              }
            ]
          }
        }
      ]
    }
  }'

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,
        'per_unit_amount': '0',
        'flat_amount': '0'
      },
      {
        'from_value': 10001,
        'to_value': None,
        'per_unit_amount': '6.25',
        'flat_amount': '0'
      }
    ]
  }
)

plan = Plan(
  name='BigQuery On-Demand',
  code='__PLAN_CODE__',
  interval='monthly',
  description='Pay-as-you-go BigQuery pricing with free tier',
  amount_cents=0,
  amount_currency='USD',
  pay_in_advance=False,
  charges=[charge]
)

client.plans.create(plan)

client.plans.create({
  name: 'BigQuery On-Demand',
  code: '__PLAN_CODE__',
  interval: 'monthly',
  description: 'Pay-as-you-go BigQuery pricing with free tier',
  amount_cents: 0,
  amount_currency: 'USD',
  pay_in_advance: false,
  charges: [
    {
      billable_metric_id: '__BILLABLE_METRIC_ID__',
      charge_model: 'graduated',
      properties: {
        graduated_ranges: [
          {
            from_value: 0,
            to_value: 10000,
            per_unit_amount: '0',
            flat_amount: '0'
          },
          {
            from_value: 10001,
            to_value: nil,
            per_unit_amount: '6.25',
            flat_amount: '0'
          }
        ]
      }
    }
  ]
})

const plan = {
  name: 'BigQuery On-Demand',
  code: '__PLAN_CODE__',
  interval: 'monthly',
  description: 'Pay-as-you-go BigQuery pricing with free tier',
  amount_cents: 0,
  amount_currency: 'USD',
  pay_in_advance: false,
  charges: [
    {
      billable_metric_id: '__BILLABLE_METRIC_ID__',
      charge_model: 'graduated',
      properties: {
        graduated_ranges: [
          {
            from_value: 0,
            to_value: 10000,
            per_unit_amount: '0',
            flat_amount: '0'
          },
          {
            from_value: 10001,
            to_value: null,
            per_unit_amount: '6.25',
            flat_amount: '0'
          }
        ]
      }
    }
  ]
};

await client.plans.createPlan({ plan })

planInput := &lago.PlanInput{
  Name:           "BigQuery On-Demand",
  Code:           "__PLAN_CODE__",
  Interval:       "monthly",
  Description:    "Pay-as-you-go BigQuery pricing with free tier",
  AmountCents:    0,
  AmountCurrency: "USD",
  PayInAdvance:   false,
  Charges: []lago.PlanChargeInput{
    {
      BillableMetricID: "__BILLABLE_METRIC_ID__",
      ChargeModel:        "graduated",
      Properties: map[string]interface{}{
        "graduated_ranges": []map[string]interface{}{
          {
            "from_value":       0,
            "to_value":         10000,
            "per_unit_amount":  "0",
            "flat_amount":      "0",
          },
          {
            "from_value":       10001,
            "to_value":         nil,
            "per_unit_amount":  "6.25",
            "flat_amount":      "0",
          },
        },
      },
    },
  },
}

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

Refer to the API reference and guide on graduated pricing 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 wallet with free credits

BigQuery lets new users try its product for free by offering upfront credits valid for 90 days. We can replicate this logic using Lago’s wallet feature.

Create a wallet with $300 of free credits for the customer
Set expiration_at to 90 days from now for the trial period

curl --location --request POST "$LAGO_URL/api/v1/wallets" \
  --header "Authorization: Bearer $API_KEY" \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "wallet": {
      "external_customer_id": "__EXTERNAL_CUSTOMER_ID__",
      "name": "BigQuery Trial Credits",
      "rate_amount": "1.0",
      "currency": "USD",
      "paid_credits": "0.0",
      "granted_credits": "300.0",
      "expiration_at": "'"$(date -u -d '+90 days' +%Y-%m-%dT%H:%M:%SZ)"'"
    }
  }'

from lago_python_client.models import Wallet
from datetime import datetime, timedelta

wallet = Wallet(
  external_customer_id='__EXTERNAL_CUSTOMER_ID__',
  name='BigQuery Trial Credits',
  rate_amount='1.0',
  currency='USD',
  paid_credits='0.0',
  granted_credits='300.0',
  expiration_at=(datetime.now() + timedelta(days=90)).isoformat() + 'Z'
)

client.wallets.create(wallet)

client.wallets.create({
  external_customer_id: '__EXTERNAL_CUSTOMER_ID__',
  name: 'BigQuery Trial Credits',
  rate_amount: '1.0',
  currency: 'USD',
  paid_credits: '0.0',
  granted_credits: '300.0',
  expiration_at: (Date.today + 90).strftime('%Y-%m-%dT23:59:59Z')
})

const wallet = {
  external_customer_id: '__EXTERNAL_CUSTOMER_ID__',
  name: 'BigQuery Trial Credits',
  rate_amount: '1.0',
  currency: 'USD',
  paid_credits: '0.0',
  granted_credits: '300.0',
  expiration_at: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString()
}

await client.wallets.createWallet({ wallet })

import "time"

expirationAt := time.Now().AddDate(0, 0, 90)

walletInput := &lago.WalletInput{
  ExternalCustomerID: "__EXTERNAL_CUSTOMER_ID__",
  Name:               "BigQuery Trial Credits",
  RateAmount:         "1.0",
  Currency:           "USD",
  PaidCredits:        "0.0",
  GrantedCredits:     "300.0",
  ExpirationAt:       &expirationAt,
}

wallet, err := client.Wallet().Create(ctx, walletInput)

Refer to the API reference to create a wallet.

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 usage.

Reference your billable metric with code
Reference the customer’s subscription with external_subscription_id
Include usage and filters data in properties

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": {
        "data_processed_volume": 10
      }
    }
  }'

from lago_python_client.models import Event

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

client.events.create(event)

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

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

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

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

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.customers.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__", &lago.CustomerUsageInput{
    ExternalSubscriptionID: "__EXTERNAL_SUBSCRIPTION_ID__",
})

Refer to the API reference to get the current usage.

Wrap-up

Offering free upfront credits is a popular strategy among AI and infrastructure companies with pay-as-you-go models like BigQuery. With Lago, you can adapt this template to your products and services using:

Billable metrics, to aggregate your pay-as-you-go usage;
Graduated charges, to price that metric on a plan; and
Wallets, to grant prepaid free credits.

Get started with Lago to build this template.

Templates

Per-token pricing

Hybrid pricing

Per-transaction pricing

Pay-as-you-go pricing

Per-seat pricing

Clone Google BigQuery pricing

Pricing structure

Get started

Wrap-up

​Pricing structure

​Get started

​Wrap-up

Pricing structure

Get started

Wrap-up