API arbitrage: How to quickly test hundreds of product ideas

As a founder, you want to test, test, test.

Here I'll present an approach to test (potentially) hundreds of products in a relatively short time with something that I call "API arbitrage".

API products make money

I've been analyzing the the IH stories database and the product database over the past week.

One thing that I've noticed while analyzing the interviews/products from the database is the larger number of successful API-based products. A few examples:

• GeoCode ($10k/mo) - a Geoparsing API

• Semantria ($150k/mo, then sold) - a sentiment analysis API

• Bannerbear ($10k+/mo) - an API to generate social media visuals, banners, etc.

• EmailEngine ($9.7k/mo) - An email client you can integrate into an app via an API

• APITemplate ($2k/mo) - an API to generate PDFs and images from reusable templates

• SerpDog ($1k/mo) - an API to access Google search data

• Whois Lookup API ($3k/mo) - a WHOIS registration info API to get data for domains

• EnrichSo ($2.6k/mo) - an API to enrich data bout people, companies, LinkedIn profiles

• ScreenshotOne ($5k/mo) - a screenshot API that converts webpages to images

Whew! That's a pretty big list of software businesses providing API access to some functionality.

Want to create your own API product?

Good luck spending months building out the functionality for it.

...and then having a good chance your idea would fail because there's no product-market fit/the competition is too stiff/marketing is too expensive, etc.

Instead of building the API, how about you outsource the functionality to another API at the beginning?

If you start making money, you could get back to building and build your own version of the API.

If you fail, move on to something else.

APIs = white label

Ever heard of "white label" software?

Those are usually SaaS products with a built-in functionality so you can sell the software as your own.

API products are "white label" by default. An API provider doesn't need to add special functionality to their software because most of the time they return raw data.

The way API products work is that they usually have URL endpoints that you can call.

You call the URL with some input, and you get some output (usually a JSON file) as a result.

Users have no idea what's going on in the background; you could be implementing your own functionality, forwarding the call to another API service (aka API arbitrage), etc.

Why do API arbitrage

Because you can test a lot of niches in a relatively short time.

All you need to build is the logic for user authentication/API credits/payments and have a place to forward the functionality to another API provider.

With an architecture like this, you could potentially create hundreds of different API products that you can test.

Another advantage of using this approach is that you can experiment with pricing.

Try setting the price of your API a bit higher/lower and see the results. Or try changing the pricing model all-together.

For example, some APIs might only provide "packages" that users could buy (each package has a pre-defined amount of API credits). If that's the case, you could experiment with a "pay as you go" package. I most companies have "pay as you go packages", you could experiment with prepaid packages.

Where to find APIs to forward to

This post has a good list of API directories. This Github repository has a huge list of public APIs. If you want to start with what's popular, see this RapidAPI post.

Part 2 of this post will focus on how to market your API.