Get Started with UsageFlow in Minutes

Setting up API metering and usage tracking shouldn't take weeks or require a team of engineers. That's why we built UsageFlow — the API metering platform that gets you up and running in minutes, not days. With just a few lines of code and zero configuration overhead, you can start tracking, metering, and monetizing your APIs instantly.

Why UsageFlow is So Simple

The simplicity comes from three core design decisions:

First, we built framework-native packages. Instead of forcing you to use a generic gateway, we created dedicated packages for Express, Fastify, and NestJS. Each package feels like it was built specifically for your framework, because it was.

Second, we eliminated configuration. UsageFlow automatically discovers your API endpoints. You don't need to manually register routes or define which endpoints to track. Just add the package, and we handle the rest.

Third, we made it work with your existing infrastructure. No need for dedicated servers or complex deployments. UsageFlow runs alongside your application, adding just 50ms of latency per request.

Installation Takes One Command

Getting started is as simple as installing the package for your framework.

For Express:

            npm
              install
              @usageflow/express
          

For Fastify:

            npm
              install
              @usageflow/fastify
          

And for NestJS:

            npm
              install
              @usageflow/nestjs
          

Three Lines of Code

Once installed, integration takes just three lines. Here's how it looks in Express:

            const
              usageFlow =
              new
              ExpressUsageFlowAPI();

              usageFlow.init('YOUR_API_KEY');

              app.use(usageFlow.createMiddleware([{ method:
              '*',
              url:
              '*' }]));
          

That's it. No configuration files, no complex setup. UsageFlow immediately starts tracking all your API endpoints automatically.

For Fastify, it's equally simple:

            const
              usageFlow =
              new
              FastifyUsageFlowAPI();

              usageFlow.init('YOUR_API_KEY');

              app.register(usageFlow.createPlugin([{ method:
              '*',
              url:
              '*' }]));
          

And NestJS uses a module-based approach:

            UsageFlowModule.forRoot({

                apiKey:
              'YOUR_API_KEY',

                routes: [{
              method:
              '*',
              url:
              '*' }]

              })
          

Auto-Discovery Makes It Effortless

The real magic happens after you add those three lines. UsageFlow automatically discovers every endpoint in your application. You don't need to tell us which routes to track—we find them automatically as requests come in.

This means you can add new endpoints to your API without updating UsageFlow configuration. Just deploy your code, and UsageFlow starts tracking the new routes immediately.

If you need to exclude certain routes—like health checks—you can whitelist them:

            usageFlow.createMiddleware(

                [{ method:
              '*',
              url:
              '*' }],

                [{ method:
              'GET',
              url:
              '/api/health' }]
              // Whitelist

              )
          

Example Apps Show You How

We've created complete example applications for each framework. These aren't toy examples—they're production-ready apps that demonstrate best practices for integrating UsageFlow.

Each example shows how to initialize UsageFlow, configure route tracking, and whitelist health check endpoints. You can clone them, add your API key, and run them immediately to see UsageFlow in action.

The examples are available in our repository and cover Express, Fastify, and NestJS. They're perfect for understanding how UsageFlow works in real applications.

What Happens After Setup

Once you've added UsageFlow to your application, it immediately starts working. Every API request is tracked and sent to your UsageFlow dashboard in real-time.

You can see which endpoints are being called, how often, and by whom. UsageFlow tracks request methods, URLs, headers, query parameters, and response codes automatically.

From the dashboard, you can configure usage-based pricing, set quotas, and create rate limits—all without touching code. Changes take effect immediately, no deployment required.

If you're using Stripe or Paddle, UsageFlow can automatically report usage for billing. Your customers get charged based on actual API usage, and you don't need to build any billing logic yourself.

Why This Matters

Most developers spend weeks building custom usage tracking systems. They write code to track requests, store metrics, and report to billing systems. Then they maintain that code as their APIs evolve.

UsageFlow eliminates all of that. You get enterprise-grade API metering with three lines of code. No custom tracking logic, no infrastructure to manage, no maintenance burden.

The simplicity extends beyond setup. When you need to change pricing or adjust quotas, you do it in the dashboard. No code changes, no deployments, no coordination between teams.

This is why UsageFlow is so powerful. It gives you the capabilities of a complex API management platform with the simplicity of a simple package. You focus on building your API, and UsageFlow handles the metering, tracking, and monetization.

Getting Started

Ready to try it? Install the package for your framework, add three lines of code, and you're done. UsageFlow will start tracking your APIs immediately.

If you want to see it in action first, check out our example applications. They're complete, working examples that show exactly how UsageFlow integrates with each framework.

The best part? There's no complex setup, no configuration files, and no infrastructure changes. Just install, integrate, and start tracking. That's how simple API metering should be.