How to Implement Outcome-Based Pricing in Moesif

Overview

Outcome-based pricing enables API providers to charge customers based on the value the product delivers. Instead of billing per API call or data volume transferred, you can define and meter pricing around key business outcomes—like completed transactions, verified identities, or jobs processed successfully.

In this tutorial, you’ll learn how to implement an outcome-based pricing model using Moesif. We’ll illustrate two examples:

  1. Tracking outcomes directly from API usage data in a telecommunications API.
  2. Tracking outcomes from external events using custom actions, such as when a batch job finishes or a report gets generated.

Background

Most API products start with a usage-based model—charging per request, per data volume unit, or per compute cycle. While this works for infrastructure services, it often fails to reflect the actual value your API delivers to customers. A customer might send thousands of requests without achieving a single business outcome, while another might send a single, high-impact request that drives conversion or revenue.

Outcome-based models shift the focus from activity to impact. Instead of billing for system usage, you define pricing around successful outcomes—for example,

  • Number of messages delivered to valid phone numbers
  • Number successful verifications of users
  • Number of generated reports

This pricing model aligns revenue with customer-perceived value, making it more transparent, defensible, and growth-oriented.

Moesif helps API providers implement outcome-based pricing by giving them the tools to track, filter, and meter business outcomes. With Moesif’s robust API product and customer analytics, you can capture such outcomes from API traffic or instrument them in the system to emit as custom business events.

For a thorough discussion on outcome-based pricing and how it’s redefining the industry, see the article Usage-based vs. Outcome-Based Pricing for APIs.

Objectives

  • Define measurable outcomes that reflect business value, such as successful SMS deliveries or completed backend jobs.
  • Track and capture outcomes from API traffic using Moesif’s API event and customer data filters.
  • Track outcomes from custom events using Moesif’s Track Actions API.
  • Configure billing meters that aggregate successful outcomes instead of raw usage volume.
  • Connect Moesif to your billing system—like Stripe or Zuora—to support monetization workflows tied to business outcomes.

Before You Start

This tutorial assumes you’ve met the following prerequisites:

Identify the Desired Outcomes That Deliver Value

First you need to define what success looks like in your product and thereby bridge product intent with technical implementation. In an outcome-based pricing model, customers pay for results—so the first question to ask is: What does a “successful outcome” look like from the customer’s point of view?

Start With Business Goals, Then Work Backward

Talk to product managers, revenue teams, or customer success. Ask what outcomes correlate with real value. The following table illustrates some examples:

Industry Customer outcome Trackable signal
Telecommunications SMS messages delivered to valid recipients Valid phone_number field in request body
Fintech Fraudulent transactions blocked Custom action that triggers upon a successful block
AI API High-quality completions or accepted responses User feedback or confidence score thresholds
Logistics Orders fulfilled within SLA Event: { "order_fulfilled": true, "latency_ms": 1260 }.
For billing purposes, you count this outcome only if latency_ms stays below 1500.
Internal ops Batch job processed successfully Track a custom action Job Finished with metadata

Avoid generic usage metrics like API calls per second. They describe system load rather than business impact. Focus on events or states that customers consider meaningful.

Properties to Look for in Outcomes

  • Measurable: You can track them with data you already generate or can reasonably emit.
  • Attributable: You can tie them back to a specific user, company, or billing account.
  • Auditable: You can explain what triggered the charge if a customer asks.

Considerations

  • Overcounting: Don’t track intermediate system events that don’t reflect real-world outcomes.
  • Overgeneralization: Don’t assume one metric applies to all customers. Enterprise customers may care about delivery rate; self-serve users may care about cost per action.
  • Hardcoding value: Avoid coupling pricing to internal system behaviors that could change during refactors.

Once you’ve identified the outcomes that matter, the next step is figuring out where to track them—in API traffic or as custom events.

Create Product and Price for Your Outcome

After identifying the business outcome you want to monetize, define a pricing plan that reflects it.

You should already have your billing provider integrated with Moesif. Now you must define the product and price before creating a billing meter. Your billing meter will reference these objects when tracking outcome-related usage and aggregating them for the metric you want to bill on. In an outcome-based pricing model, the payment structure is directly linked to the outcomes tracked by the billing meter, ensuring clients’ payments correspond to the specific results achieved.

You can create your product and prices directly in Moesif using Product Catalog. Moesif attributes the usage to a plan and meters according to the Price.

For instructions, see Creating a Plan and Creating a Price.

The next sections go through two examples demonstrating how to track and define outcomes using API events and custom actions.

Track Outcomes from API Traffic

If you can infer outcome directly from your API traffic data, you can use Moesif’s event filtering to accurately specify the relevant data, while ruling out irrelevant events. Then you define the metric to bill on.

For example, here we demonstrate creating a billing meter a telco use case: billing customers based on the number of people in the US receiving SMS messages successfully. Each qualified request represents a successful outcome that creates real business value.

Define the Outcome Logic

In this case, a billable outcome must pass these criteria:

  • An HTTP request to the /messages/:id endpoint
  • The corresponding phone number is a U.S. phone number

This represents a qualified delivery attempt for value-aligned usage.

Filter API Traffic to Match Outcomes

When creating the billing meter, let’s apply the following filters:

  • Request.URI Route set to /messages/:id
    • Request.body.phone_number starts with "1"

This makes sure that Moesif disregards API activity that don’t relate with the pricing model, outcome, and target customer base.

Define the Billable metric

In the Metrics pane of the Billing Meter, define the billable metric. Moesif has some built-in metrics across categories like volume, performance, and payload metrics. You can also select a custom field and choose the aggregation method for it. Moesif offers flexible aggregations based on the data type of the field values. For example, for numeric fields, you can calculate sums and averages.

In this example, we specify one of the built-in metrics that counts the number of elements present in the request body to bill on the number of distinct people reached.

An example billing meter in Moesif for a telecommunications API.

In combination with the following price definition, the pricing model sums up the total number of people reached in each month and applies the unit price of $0.008.

An example price structure in Moesif for a telecommunications API.

Track Outcomes Using Custom Actions

Some outcomes occur outside API calls—for example, in internal workflows, asynchronous jobs, or external systems. In those cases, you can use Moesif’s custom actions to track outcomes explicitly while attaching them to users and companies.

This section walks you through an example KYC (Know Your Customer) API product to demonstrate how to implement outcome-based pricing using custom actions.

Use Case: Outcome-Based Pricing for KYC Identity Verification

Let’s say you offer an API that automates KYC checks. Your customers send in user-submitted documents like passports and utility bills, and your system performs tasks like the following:

  • Document classification
  • OCR and data extraction
  • Fraud detection
  • Match and validation against submitted form data

The backend, using an AI pipeline, handles these steps. Customers never interact with the AI models directly but rather the relevant API endpoints. However, they expect to know whether the process completed successfully and how reliable the results are.

When a full KYC check completes, the backend emits a custom action Complete AI Process Pipeline. The action includes a job_score metadata field, with a value from 0 to 100 representing the confidence score of the result. This score is the outcome to track, meter, and bill customers on.

Implement Pricing

To support different risk profiles and pricing needs, you offer three tiers:

Plan Tier Score range
Starter 0–70
Growth 71–94
Enterprise 95–100

Higher tiers may also come with perks like more volume usage. For example, Enterprise users can enjoy over 100k volume each billing period.

Emit the Outcome Event

Once the AI processing pipeline completes successfully, emit a custom action like this:

{
  "action_name":"kyc_check_completed",
  "request":{
    "time":"2025-05-28T04:45:42.914"
  },
  "user_id":"user_987",
  "company_id":"fintech_inc",
  "metadata":{
    "kyc_id":"kyc_0038",
    "job_score":96,
    "document_type":"passport",
    "model_version":"v2.1"
  }
}

Create Billing Meters for Each Tier

Now define billing meters based on each tier’s criteria. For example, the following shows a billing meter for the Enterprise tier:

An example billing meter in Moesif for an Enterprise tier of a product.

It specifies the job_score field as the metric to bill on and sum as the aggregation method.

The following illustrates an example volume-tier model for Enterprise users. It starts with $0.10 and offers a higher number of cumulative score usage than other tiers. Notice that this time Moesif links to a Stripe Meter named Enterprise:

An example volume-tier price structure in Moesif.

For example, if a customer completes 500 KYC checks in a month, each with a job_score of 95, the total score becomes $47,500.

  • The first 10,000 units are billed at $0.10
  • The next 37,500 units are billed at $0.05

Therefore, customer receives an invoice of $1,000 + $1,875 = $2,875

Analyze and Monitor Outcomes

  • Use Segmentation to view KYC volume by customer or region.
  • Use Funnels to trace submission to successful KYC completion.
  • Use Dashboards to create, organize, and share analysis reports illustrating trends in verification quality across plans or document types

Best Practices

To successfully implement an outcome-based model, you need a feedback loop rooted in transparent measurement, modular design, and clear communication. By building for continuous improvement, you can maintain revenue growth while delivering measurable value to customers.

Here are some best practices to help ensure your setup reflects your business strategy, supports sustainable revenue models, and accounts for real-world factors like energy and maintenance costs.

Use Outcomes Your Customers Understand

Choose, define, and instrument outcomes so that they align with your customer’s success metrics rather than internal system states. For example, "Check Completed" or "Report Generation Complete" is clearer than "pipeline_v4_succeeded".

Validate Outcome Events Before Billing

Use Moesif’s Live Event Log, dashboards and other analytics tools to verify that custom actions or event filters match real-world usage. Catch overcounting, edge cases, or payload drift early.

Use Meaningful Aggregations

Think carefully about how you meter outcomes:

  • Use the distinct aggregation operator for discrete events like successful completions
  • Use sum, avg, or other numeric operators for weighted metrics like confidence scores.

Keep Your Billing Meters Modular

Avoid hardcoding too much business logic into a single meter. Use one meter per tier or outcome type. This gives you flexibility to evolve plans without rewriting tracking infrastructure.

Expose Outcome Data to Customer-Facing Teams

Share outcome metrics with sales, customer success, and support through Moesif’s dashboards, Billing Report Metrics, and Embedded Templates. This improves transparency, helps teams tie pricing to results, and reduces disputes.

Next Steps

Updated: