The agencies making the most out of an SEO audit API aren't using it as an internal tool. They're using it as the engine behind a product they sell to their clients. Branded login, monthly subscription, automated reports — a small SaaS, owned by the agency, that happens to be powered by SEO Score API on the backend.

This post is the blueprint for that play. Architecture, auth, branding, billing, and the actual unit economics of running it on Ultra at $99/mo.

The shape of the product

The minimum-viable white-label SEO product an agency can charge for:

  1. Branded login. Client logs into seo.youragency.com. Your logo, your colors. They don't know SEO Score API exists.
  2. A dashboard of their sites. All their domains, current scores, 30-day trend.
  3. A weekly email. "Here's how your sites scored this week. Three things regressed; here's what."
  4. A downloadable PDF report. Monthly. Their logo. Their KPIs.

That's the surface area. None of it is hard. All of it is sellable for $50–200/month per client, depending on your market.

Architecture

The cheapest viable stack:

┌────────────────────────┐
│   seo.youragency.com   │  Next.js / Rails / Django — whatever you know
│   (auth + dashboard)   │
└────────────┬───────────┘
             │
             │ stores client → domains mapping
             ▼
   ┌──────────────────┐
   │   Your database  │  Postgres or SQLite is fine
   │   (users, sites) │
   └──────────────────┘
             │
             │ daily cron: for each tracked domain, call /audit
             ▼
   ┌──────────────────────────┐
   │   api.seoscoreapi.com    │  one API key, used server-side
   │   /audit  /history       │
   └──────────────────────────┘

You hold the customer relationship. You hold the billing. You hold the data ownership. The API does the actual audit work.

Total infrastructure: a small VPS or a serverless function, a Postgres instance, and one SEO Score API key on the Ultra plan. That's $99/mo plus ~$20/mo of hosting.

The daily job

The whole backend is essentially this loop:

import requests, sqlite3, time
from collections import defaultdict

API_KEY = "your-ultra-key"
BASE = "https://api.seoscoreapi.com"

db = sqlite3.connect("agency.db")
sites = db.execute("SELECT id, url, client_id FROM tracked_sites").fetchall()

for site_id, url, client_id in sites:
    r = requests.get(
        f"{BASE}/audit?url={url}",
        headers={"X-API-Key": API_KEY},
        timeout=120,
    )
    if r.ok:
        data = r.json()
        db.execute(
            "INSERT INTO audit_results (site_id, ts, score, payload) VALUES (?, ?, ?, ?)",
            (site_id, time.time(), data["score"], r.text),
        )
        db.commit()

Run that as a daily cron. Each audit takes 5–15 seconds. For 100 sites that's a 10–25 minute job. For 500 it's an hour. The audits themselves run in parallel on our side; the loop above just sequences them client-side.

The history endpoint does the heavy lifting for the dashboard — you don't need to write your own time-series queries:

r = requests.get(
    f"{BASE}/history?url={url}",
    headers={"X-API-Key": API_KEY},
).json()
# r["history"] is a full per-day timeseries
# r["summary"] has min/max/avg

White-labeling the reports

The trick that lets you skip a lot of frontend work: the /report/{domain} HTML report at api.seoscoreapi.com is already a clean, standalone page. You can either:

(a) Wrap it in an iframe inside your branded shell.

<div class="agency-header">
  <img src="/your-logo.png">
  <nav>Dashboard | Reports | Settings</nav>
</div>
<iframe src="https://api.seoscoreapi.com/report/client.com?embed=1"
        style="width:100%;height:90vh;border:0;"></iframe>

(b) Render your own UI from the JSON. More work, more control. For agencies that want a true product, this is what most ship eventually.

For PDF generation, WeasyPrint or Puppeteer over your own HTML template is the answer. Pull the audit JSON, render an HTML report with your branding and the client's KPIs, convert to PDF, email it.

Billing the clients

Stripe Billing is the obvious answer. The shape:

  • Tier 1: Monitor only. $49/mo. One domain, weekly audits, monthly PDF.
  • Tier 2: Multi-site. $149/mo. Up to 10 domains, weekly audits, monthly PDF, Slack alerts.
  • Tier 3: White-glove. $399/mo. Up to 50 domains, weekly audits, monthly PDF, dedicated analyst review (you).

Stripe Billing handles the subscription, payment, dunning, invoicing. You handle the workflow. SEO Score API handles the audits.

The unit economics

This is the part that makes the play work. Concrete numbers, conservative:

Your costs (monthly):

  • SEO Score API Ultra: $99
  • VPS + Postgres: $20
  • Stripe fees: ~3% of revenue
  • Fixed overhead: ~$120/mo

Your revenue per client:

  • Average plan: $150/mo (mix of tiers above)
  • Cost to serve per client (Ultra has 25,000 audits/mo): essentially $0 marginal

Breakeven: 1 paying client.

At 10 clients: ~$1,500/mo MRR, ~$1,380 net after costs. At 30 clients: ~$4,500/mo MRR, ~$4,380 net. At 50 clients: ~$7,500/mo MRR, ~$7,380 net.

The cost ceiling stays flat until you exhaust Ultra's 25,000 audits/mo, which at weekly audits across 30 domains is ~3,500 audits — you've got 7x headroom.

This isn't a thought experiment. We've seen agencies hit $5K MRR within six months of standing up a white-label product over the API. The constraint is not technical; it's sales pipeline.

What the API does for you that DIY doesn't

Worth being explicit about. The agencies that have tried to build this themselves — running a headless browser, parsing pages, computing scores — almost always come back to the API within a quarter. Reasons:

  • Score consistency. When the methodology has to be defended to a client ("why did our score drop?"), you don't want to be the one explaining your bespoke scoring algorithm. You want to point at a third-party score with documentation.
  • Maintenance burden. Web standards drift. Headless browsers update. Performance metrics get redefined (LCP, INP). Keeping a homegrown auditor accurate is a part-time job. Outsourcing that is the whole point.
  • Compute cost. Running Chromium in a Lambda or EC2 instance for every audit isn't cheap. Aggregate compute on a shared platform is.
  • AI readability and GEO scoring. Building the LLM-bot-aware analysis layer from scratch is its own engineering project. The API ships it.

The build-vs-buy math comes out roughly the same as the Screaming Frog math: at small scale buying wins, at large scale it gets even more decisive because your team's time is the expensive resource.

A simple legal note

Two things to handle on the resale side:

  1. Your terms with your clients should reflect that you provide the service. You're not reselling SEO Score API as such — you're providing an SEO monitoring service that happens to use it. Clean.
  2. Don't pass through API keys to clients. Your Ultra key is yours. Each client gets a login to your product, not to api.seoscoreapi.com. This isn't a hard rule — there are agencies who do hand keys directly — but for a white-label play, holding the integration server-side is the standard pattern.

What to ship first

Don't build the whole product before you have a customer. The order we've seen work:

  1. Week 1: Pick three existing clients. Stand up the daily cron audit. Email them a weekly recap manually. See if they engage.
  2. Week 2-3: Build the dashboard. Login, one page, current scores + 30-day trend.
  3. Week 4: Wire up Stripe Billing. Charge $49/mo. See if existing clients convert.
  4. Month 2+: PDF reports. Slack alerts. Tier-up.

The minimum viable product is "email + dashboard." Everything else is iteration based on what clients actually use.

Getting started

The whole play needs the Ultra plan ($99/mo) — partly for the audit volume, partly because Ultra ships unlimited history retention which is what makes the trend charts and yearly reports actually work. If you're testing the concept with three clients first, Pro ($39/mo) covers the audit budget but caps history at one year — fine for a six-month pilot, less fine for a long-term product.

If you're already running an agency and have 10+ clients who would value continuous SEO monitoring, the math works out before you finish reading this paragraph. The API is doing the hardest part. The hardest part for you is sending the first sales email.