How to monetize APIs

This guide outlines the process of share and monetizing APIs on Ouro. We'll cover the essential steps including API development and deployment, monetization onboarding, and effective strategies for marketing your service. By following this guide, you'll have all the tools to start earning from your API.

Introduction

APIs can be a broad concept, but on Ouro, we understand them as functionalities accessible through HTTP requests. This includes the common HTTP verbs like GET, POST, PUT, DELETE, and others that structure these web functionalities.

One way to think of Ouro is as an API for APIs. We provide a wrapper around your API, handling the complexities of:

• User management & security
• Monetization
• Analytics

This allows you to focus on creating valuable functionality without worrying about the overhead of turning it into a product.

Platform users can interact with added APIs in two ways:

• Through Ouro's API: Enabling programmatic access
• Via the web interface: Using automatically-generated, easy-to-use forms

This framework elevates your API with additional functionality and a user-friendly face. It also facilitate seamless integration with other assets on the platform, enhancing the overall value and usability of your API.

1. Getting started

If you already have an API you want to add to Ouro, you can skip this part. If you're still in the development process, this section will help you understand what makes an API useful and why someone might pay for it.

What kind of APIs to share?

Ouro supports a wide range of API functionalities. If you have a service that can be accessed via HTTP requests, you can monetize it on the platform.

Here are some categories of APIs that tend to sell well:

• AI and machine learning models as a service
• Data processing and transformation services
• Media (text, image, video) modification and generation services
• Data retrieval, enrichment, and validation services
• Industry-specific tools and calculators

The key to success is designing your API in a way that's accessible, reliable, and valuable to potential users. Well-documented APIs with clear use cases and solid performance are always in demand. Making your API compatible with the assets on the platform is one way to do that.

Consider these qualities when developing your API:

• Uniqueness: What does your API offer that isn't readily available elsewhere?
• Reliability: How stable and consistent is your API's performance?
• Documentation: Is your API well-documented and easy to integrate?
• Potential applications: What problems does your API solve or what processes does it improve?

Focus on your technical strengths and domain expertise. Whether you're a software developer, data scientist, or industry specialist, your unique skills can translate into valuable API services. By understanding the market needs and presenting your API effectively, you'll find users eager to integrate your functionality into their workflows or applications.

2. Preparing your API

Before integrating your API with Ouro, we'll need to make sure the service has the following:

• Accessible from the web via HTTP requests. You'll still be able to secure and harden your service with API keys, rate limiting, and domain allow-listing.
• An OpenAPI spec file (JSON or YAML format) defining the API.
  • If you're just getting started, consider FastAPI, a web framework for building APIs with Python. FastAPI provides built-in support for generating OpenAPI specs.
  • ChatGPT or Claude is able to generate specs for you as well.

Deploying your service

To make your API accessible from the internet, you need to deploy it to a web server or use a service that handles web service hosting. You're more than welcome to deploy it yourself to a cloud environment, your own server, or a managed platform. Here are some platforms to check out:

• Fly.io
• Render
• Railway
• Vercel
• Heroku

Choose a deployment strategy that suits your needs. You can find hosting guidance in the Hosting and availability section of the docs. These services have been recommended because of their comprehensive documentation and guides developed to make deploying your app easy. Use them to your advantage!

Generating an OpenAPI spec

OpenAPI specs offer a comprehensive blueprint of your API, detailing each route, along with the format and structure of expected inputs and outputs. Ouro will use this information to automatically generate an interactive form and prepare the route for handling platform assets as inputs or outputs.

Don't worry if you haven't created an OpenAPI spec yet. This guide will walk you through the process. Developing an OpenAPI spec will be valuable resource that will enhance your API's usability both on Ouro and in other contexts. They're often also used to define AI agent tools, SDK generation, API testing, and more.

If you're using FastAPI, you can access your OpenAPI spec, automatically created for you:

1. Define your API endpoints using FastAPI's decorators and Pydantic models.
2. Add descriptions to your API routes, parameters, and models.
3. Specify the expected response model for each endpoint using the response_model parameter.
4. Run your FastAPI application and access the generated OpenAPI specification at the /openapi.json endpoint.

Below is an example FastAPI app, with examples of how to add additional metadata to your app and routes so that the generated OpenAPI spec includes all the needed information.

from fastapi import FastAPI
from pydantic import BaseModel
 
app = FastAPI(
    title="My Item API",
    description="This API allows you to create and manage items.",
    version="1.0.0"
)
 
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None
 
@app.post(
    "/items",
    response_model=dict,
    summary="Create an item",
    description="Create a new item with the given details.",
    response_description="The created item"
)
async def create_item(item: Item):
    return {"item": item}

If you're not using FastAPI, you'll still be able to generate a spec. They can be written manually, or by pasting your app code into ChatGPT or Claude and ask for an OpenAPI spec to be generated. We're working on making this process smoother. If you have questions or need any help, let us know.

If your routes accept Ouro assets as input or create Ouro assets as output, add Ouro-specific OpenAPI extensions to make them show up in the right workflows. For simple file-input routes, x-ouro-input-asset-type: file still works; for named inputs or multiple outputs, prefer keyed x-ouro-input-assets and x-ouro-output-assets. Use the route input and output assets guide for the full declaration and response shapes. The older single-value x-ouro-input-file-extension is still supported, but new specs should prefer the array form x-ouro-input-file-extensions when using legacy single-input declarations.

3. Add the service to Ouro

With your OpenAPI specification ready and your app deployed, you can now create the service on Ouro:

1. Go to the Water layer in the Ouro web interface.
2. Use the Water Create form to create a new Service.
3. Provide your OpenAPI specification in one of two ways:
   • Upload a file: Upload your OpenAPI specification file (JSON or YAML)
   • Provide a URL: Enter the URL where your spec is hosted (e.g., https://your-api.com/openapi.json)

Ouro will automatically parse all the necessary information from the spec to define the service and each route. When using a URL, we fetch and store a copy of the spec for fast access, so even if your remote spec changes, the version in Ouro remains stable until you update it.

Testing your integration

Before monetizing, thoroughly test your API to make sure it's working as expected. You can use the form generated for each route to test the integration with the platform.

1. Verify each route with various inputs to ensure expected responses.

2. For routes using assets as input:

   • Confirm you can select the correct asset type
   • Confirm extension-restricted routes only appear for compatible files
   • Ensure your API properly receives and processes the asset

3. For routes creating assets as output:

   • Check that the data returned matches the specified asset type format
   • Verify that a side effect is created when the route is called

Please take extra care with this step and don't hesitate to let us know if something's not right. Attention at this step will help ensure a smooth user experience and proper integration the rest of the platform.

4. Monetize your routes

Monetization is set per route and is available on every plan. Choose a route to edit, set Access to Monetized, and choose which currencies to accept:

• USD: callers pay from their Ouro balance, prepaid one run at a time (topped up by card, with optional auto-reload). Callers can set a monthly spending limit.
• BTC: callers pay in sats from their Bitcoin wallet. No identity verification is needed on either side, which makes it the natural choice for routes that agents call.

You can accept both. Each currency gets its own price, and callers choose which to pay in. Ouro doesn't convert between them, so you decide what a run costs in dollars and what it costs in sats. Accepting both lets people pay by card and agents pay in sats on the same route.

Then choose how each run is priced:

• Per run: every successful run costs the same fixed amount.
• Per second: the caller pays a per-second rate for as long as the run takes, up to a maximum you set per run. A route sold in both currencies has a rate for each and one shared maximum. This suits jobs whose length you can't predict, like simulations or GPU work on Modal.
• Per unit of input (set through the API with cost_accounting: "variable"): the caller pays a unit rate times the size of their input:
  • Files: megabytes; audio: seconds of audio
  • Datasets: row count
  • Posts: word count or character count

However a route is priced, failed and timed-out runs are free.

How per-second pricing works

1. Before the run, Ouro holds the rate times your maximum from the caller's balance. If the caller can't afford the full maximum, Ouro holds what they can afford instead, with a 60-second minimum. The price is fixed for the run at this point, so editing it later doesn't change what an in-progress run costs.
2. Your service gets the run's budget in the ouro-max-billable-seconds request header. That's the most seconds the run can be billed. Use it as your job's time limit, or reject jobs that won't finish in time; a rejected run is free for the caller.
3. When the run finishes, Ouro charges the seconds from when it called your service to when the result arrived, capped at the budget, and returns the rest of the hold. Your service can report fewer billable seconds (for example, its own compute time), and Ouro bills the smaller number.
4. Runs that go long past the budget aren't billed for the extra time. A run still going 15 minutes after its budget is timed out, and the caller's hold is released.

See long-running APIs for the webhook details.

Callers see the price on the route page and in your service's route table before they run anything, and a receipt after each run.

Getting paid

Your earnings (minus the 30% platform fee) arrive as soon as a run succeeds, in the currency the caller paid in. You run your own routes for free, in either currency, and so does anyone with write or admin access to the route or its service.

• USD: anyone can sell in USD. Until you verify your identity, you can earn up to $100 in total. Earnings are spendable right away and withdrawable after 7 days; withdrawing requires verification. To verify, go to Settings → Wallet, select the USD tab, and click Verify.
• BTC: payments land in your Bitcoin wallet immediately, with no verification needed.

We're working on more pricing models. Request one if these don't cover your needs.

5. Share and promote your API

Each route page is also a public profile for your API that's accessible to anyone, even those without an Ouro account. This page showcases a summary of your API's capabilities plus links to documentation and other connected posts. While the full functionality is reserved for paying customers, this preview gives potential users a clear idea of what your API offers.

It's worth the time spent crafting an engaging API name and compelling descriptions to capture the interest of potential users.

Share to social media

Leveraging social media platforms is a powerful way to amplify your API's visibility and reach potential users beyond the Ouro ecosystem. Use the built-in sharing tools to post about your API on popular platforms like X and LinkedIn. These posts automatically include a link to your API's public page, making it simple for interested parties to learn more.

Create on Ouro

After launching your API on Ouro, keep the momentum going by consistently sharing valuable content. Create public posts that highlight the practical benefits and unique features of your API. Consider some of the following:

• Tutorials on implementing your API for specific use cases
• Success stories from early adopters of your API
• Comparisons showing how your API outperforms alternatives
• Technical deep dives into your API's underlying technology
• Quick-start guides with sample code for easy integration
• Regular updates on new features or improvements

Make sure to link the route in your post so users can get to it when they come across the post.

The key is to provide genuine value to the Ouro community. By consistently offering helpful insights and engaging in meaningful discussions, you'll naturally attract interest in your API. This approach builds trust and showcases your expertise, making your API more appealing to potential users.

Your content should demonstrate how your API solves real-world problems or enhances existing workflows. This strategy not only promotes your API but also contributes to the overall knowledge base of the Ouro community.