Before you write a single line of integration code, you should feel an API — see the real response shapes, poke the edges, confirm it does what the docs claim. Postman is the fastest way to do that, and the SEO Score API is small enough to tour completely in one sitting. This post sets up a reusable Postman collection and walks every endpoint you'll actually use.

By the end you'll have a working collection you can keep as your scratchpad — and a clear sense of whether the API fits, which is the whole point of evaluating before you commit.

Step 1: create a collection with shared auth

In Postman, create a new collection called SEO Score API. Open its Variables tab and add two:

Variable Initial value
base_url https://seoscoreapi.com
api_key your key from seoscoreapi.com/#signup

Then open the collection's Authorization tab, choose API Key, and set:

  • Key: X-API-Key
  • Value: {{api_key}}
  • Add to: Header

Every request in the collection now inherits the header automatically — you set the key once and never paste it again. Get a free key at seoscoreapi.com/#signup if you don't have one.

Step 2: your first audit

Add a request: GET {{base_url}}/audit?url=https://example.com.

Hit Send and read the response. You'll get an overall score (0–100), a letter grade, a priorities array of the highest-impact fixes, and an audit object breaking the score down by category — SEO, performance, accessibility, AI readability. This one response is the core of the whole product; everything else is a way to run it at scale or on a schedule.

Try a real URL of your own next. Seeing your own site's priorities list is the moment the API stops being abstract.

Tip: the very first time you audit example.com, the API waves you off with a friendly note instead of a score and doesn't charge it against your quota — it's nudging you toward a site you actually care about. Point it at a real URL to see the full response.

Step 3: batch several URLs at once

Add a request: POST {{base_url}}/audit/batch, with a JSON body:

{
  "urls": [
    "https://example.com",
    "https://your-site.com",
    "https://a-competitor.com"
  ]
}

Send it and you'll get back { "count": 3, "results": [ ... ] } — each result identical to a single audit, plus a history delta block. Batch is paid-plan only and capped at 10 URLs per request; a free key gets a 403 here, which is itself useful to see so you know the boundary. This is the endpoint you reach for when auditing a whole site or a competitor set.

Step 4: check your usage

Add a request: GET {{base_url}}/usage.

The response shows where you stand against your plan's limits — audits used, your daily and monthly caps, and your requests-per-minute ceiling. This is the endpoint your integrations should poll before a bulk run so they can pace themselves instead of walking into a 429. It's a one-second sanity check you'll come back to often.

Step 5: set up monitoring

Add a request: POST {{base_url}}/monitors, with a JSON body:

{
  "url": "https://your-site.com",
  "frequency": "daily",
  "webhook_url": "https://hooks.slack.com/services/...",
  "alert_threshold": 5
}

This registers ongoing score monitoring (paid plans). If webhook_url is a Slack incoming webhook, alerts arrive as formatted Slack messages; otherwise the raw event JSON is POSTed wherever you point it. Drop the webhook field entirely and it just tracks. Send GET {{base_url}}/monitors to list what you've registered. This is the continuous-monitoring feature exposed as two simple requests.

Why won't my request authenticate?

Nearly always the X-API-Key header. Confirm the collection's Authorization tab is set to API Key → Header with value {{api_key}}, and that a request isn't overriding it with its own No Auth setting (a request's own auth beats the collection's). Check the resolved value by hovering the {{api_key}} token — if it shows empty, you set the variable in the wrong scope. Setting auth at the collection level, once, avoids the whole class of "works on one request, 401 on the next" confusion.

How do I share this collection with my team?

Use Postman's Export on the collection to produce a JSON file, or share it into a Postman workspace. Export without your key baked in — because api_key is a variable, teammates just fill in their own value and every request works. That's the payoff of the variable setup: one collection, many keys, zero copy-pasting secrets into request headers.

What should I look at to decide if the API fits?

Three things, all visible in this tour. Response shape: is priorities structured the way your code wants to consume it? Latency: watch Postman's timing on a real audit — that's what a synchronous call in your pipeline will cost. Limits: the /usage numbers against the pricing tiers tell you which plan your real volume needs. Clicking through those in five minutes tells you more than any spec sheet, which is exactly why Postman is the right first step.

Where to take it next

Once the collection feels right, turn a request into code: Postman's Code button (the </> icon) generates a ready-to-paste snippet in curl, Python, JavaScript, and more for any request you've built. From there, the five real workflows post shows what teams actually assemble from these same four endpoints.

Five minutes of clicking beats an afternoon of guessing. Build the collection, run the tour, and you'll know exactly what you're working with.