From Raw HTTP to Clear Decisions: Geekflare API + OpenAI API Website Health Briefs
Category: Monetization Guide
Excerpt:
Most teams collect dozens of website metrics but can’t tell a simple story: what broke, what’s slow, and what to fix this week. This tutorial shows how to combine Geekflare’s scraping, performance, and security APIs with the OpenAI API to build automated “Website Health Briefs” for clients. You’ll get a concrete, step‑by‑step workflow you can sell to agencies and site owners—without promising magical SEO results, just reliable insight and prioritized actions.
Last Updated: February 1, 2026 | Use case: “Website Health Briefs” for agencies, freelancers, and busy site owners | Focus: turn raw HTTP checks into short, useful reports—no hype, no magic promises
Field notes from real projects
One client had: uptime monitoring, PageSpeed, an SEO crawler, a separate security scanner, and manual Lighthouse runs. When their checkout dipped, everyone sent different screenshots. Nobody had a single Yes/No answer for “is this urgent?”
Another agency proudly shipped a 26‑page PDF every month. Beautiful design, dozens of charts. The founder quietly admitted: “I skim page one for red, then close it. I just want to know what my team should do.”
Performance dips. SEO blames bloated scripts. Dev blames old CMS templates. Infra blames the shared host. Without clear, cross‑cutting data (broken links, TLS, load time, Lighthouse), the conversation turns political instead of technical.
I’ve been that freelancer who “quickly checks” a client’s site whenever they panic, then spends 2–3 hours clicking around tools and writing explanations—for free. That’s exactly the time your future “Website Health Brief” is meant to capture and package.
The two tools, zero fluff
Geekflare API is a suite of 10+ HTTP‑based APIs under one subscription: web scraping, screenshots, metadata, DNS, TLS, site load time, broken links, Port scanner, Lighthouse, and more. One credit system, one API key, with a free tier of 500 credits/month and paid plans starting around $9/month.
- Load Time API： get TTFB / total load time + status codes.
- Broken Link API： find dead internal / external links.
- TLS Scan API： cert issuer, expiry date, protocol support.
- Lighthouse API： performance, SEO, accessibility scores.
- Screenshot API： visual proof of “here’s what users see.”
- Web Scraping API： extract content/metadata into JSON or Markdown for AI.
All of them use the same auth style:
HTTP POST with x-api-key in headers.
The OpenAI API gives you frontier models (GPT‑4.1, reasoning models like o3, etc.) through a simple HTTP interface with Bearer auth. You send structured data (like the JSON results from Geekflare), the model sends back analysis, summaries, and prioritized actions.
- Take multiple Geekflare API responses as input.
- Have the model write a Website Health Brief in plain language.
- Ask it to output JSON “task lists” for dev/SEO teams.
- Optionally, power a small Q&A chat for “why did the score drop?”
Important: API keys live on your backend only. OpenAI’s docs stress not to expose keys in frontend code.
What you’re building: a small “Website Health Brief” system
Strip away the tech, and your system is just three moving parts:
A script (cron job) that calls Geekflare’s APIs for a domain: load time, Lighthouse, TLS, broken links, maybe a screenshot. It stores the raw JSON responses in a dated folder or database.
A backend endpoint that: loads yesterday’s results → sends them to OpenAI with a clear prompt → gets back a concise report + JSON of prioritized issues.
A small job that formats the report and sends it where people already live: email, Slack, Teams, or your client portal. That’s the part they experience as “the service.”
Implementation（step‑by‑step, nothing hidden）
- Go to
https://geekflare.com/api/and click “Get API Key”. - Start on the Free plan: 500 monthly credits, which is enough to build and test.
- In your dashboard, copy the API key. You’ll use it as
x-api-keyin request headers. - Pick a test domain (your own site or a friend’s).
From the Geekflare API docs, try:
- Load Time API → basic performance + TTFB.
- Broken Link API → to see if their blog is full of dead links.
- TLS Scanner → to check certificate expiry and protocols.
- Lighthouse API → to pull performance/SEO/accessibility scores.
- Store the responses as JSON files with a clear naming convention:
data/ myclient.com/ 2026-02-01-loadtime.json 2026-02-01-brokenlinks.json 2026-02-01-tls.json 2026-02-01-lighthouse.json
这一步不要追求“完美覆盖所有指标”，先固定住 3–4 个最常见的痛点：速度、链接、证书、基础 SEO。
Instead of sending five different API responses to OpenAI, normalize them into one compact object. Something like:
{
"domain": "myclient.com",
"date": "2026-02-01",
"performance": {
"ttfb_ms": 420,
"loadtime_ms": 2100,
"status_code": 200,
"lighthouse": {
"performance": 78,
"seo": 91,
"accessibility": 88
}
},
"links": {
"checked": 652,
"broken_total": 17,
"broken_internal": 9,
"broken_external": 8,
"example_broken_urls": [
"https://myclient.com/blog/old-post",
"https://external.com/dead-page"
]
},
"tls": {
"issuer": "Google Trust Services",
"valid_from": "2025-01-04",
"valid_to": "2026-04-03",
"days_to_expiry": 62,
"supports_tls13": true
}
}This is the “truth” your AI report will lean on. It doesn’t have to capture everything Geekflare can do—just what helps answer “are we okay, and what do we fix first?”
- Create an OpenAI account (if you haven’t) and generate an API key in the platform dashboard.
- Store it in your backend environment variables (for example,
OPENAI_API_KEY), not in frontend code. - Pick a current flagship text model from the docs (for example, a GPT‑4.1 level model or a reasoning model if you like).
- Create a backend function like
generateHealthBrief(snapshotJson)that:- Constructs a prompt with your JSON in the “system” or “input” section.
- Asks for a short report + a structured list of issues.
Example prompt skeleton:
SYSTEM:
You are a calm, honest website health analyst.
You never promise traffic or ranking, you only report what you see
and suggest practical next actions for the next 7 days.
USER:
Here is the latest health snapshot for a website (JSON below).
Write two things:
1) A short "Website Health Brief" in plain English, max 400 words.
Structure:
- Overall status (1–2 sentences)
- Top 3 issues (bulleted)
- Quick wins this week (bulleted)
2) A JSON object called "action_plan" with fields:
- "urgency" (string: "low" | "medium" | "high")
- "issues": array of objects:
{ "type": "performance|links|tls|seo",
"description": "string",
"recommended_owner": "dev|content|infra|seo",
"impact": "low|medium|high"
}
HEALTH SNAPSHOT JSON:
<your aggregated JSON here>Keeping the output partly plain text + partly JSON allows you to both email the human‑friendly report and push the tasks into whatever system (Notion, ClickUp, Trello) your client uses.
The last piece is where this becomes a service and not just “I ran some scripts.”
- Set up a cron job (or equivalent) to:
- Run Geekflare checks for each client domain at, say, 03:00 their local time.
- Aggregate into JSON snapshots.
- Call your OpenAI “analyst” function to generate the brief + action_plan.
- Format an email:
- Subject:
[Weekly Health] {{domain}} — {{high_issues}} high, {{medium_issues}} medium - Body: paste the plain‑English report from the model.
- Footer: link to a dashboard or a shared doc where you track trends over weeks.
- Subject:
- Optionally: write the JSON action items into a Google Sheet / Notion DB so your client can track “done / not done”.
Your real value is the routine: the fact that every Monday at 7:15am, without you manually touching anything, your client gets a brief that makes sense.
Turn this into offers people can say “yes” to
You’re not trying to sell some abstract “AI solution.” You’re selling: “Every week, I’ll tell you if your site is okay, where it’s bleeding, and who needs to fix what.” Here are some honest packages that fit that promise:
| Package | What’s included | Best fit | Realistic price range |
|---|---|---|---|
| Basic Health Brief |
· Weekly Geekflare checks (Load Time, TLS, Broken Links, Lighthouse) · 1 “Website Health Brief” email per week · Simple action list (3–7 items) in the email · 30‑minute onboarding call to define thresholds (what counts as “red”) | solo founders, small e‑commerce, SaaS landing pages | $120 – $350 / month / domain |
| Agency Client Add‑On |
· Everything in Basic, but white‑labeled (your branding) · Multi‑domain support (3–10 domains per account) · One monthly “roll‑up” report comparing all client sites · Optional Slack integration for high‑urgency issues (e.g., certs expiring soon) | marketing / SEO agencies managing multiple client sites | $300 – $900 / month / agency (plus per‑domain fee, e.g. $40–$80) |
| Quarterly Deep‑Dive |
· One‑off project every quarter · Extra Geekflare checks (screenshots, PDFs, port scan if relevant) · A longer report (maybe 6–10 pages) generated with OpenAI then edited by you · 60‑minute review call walking through findings and priorities · Optional: you open dev/SEO tickets for them in their system | larger sites, management teams that want a “state of the site” review | $800 – $2,500 / quarter / site |
Hey [Name] — quick question about your website. Right now, when something breaks (speed, links, SSL, SEO basics), how do you find out? Most teams only discover issues after a customer complains or a launch flops. I run a small “Website Health Brief” service: - Geekflare API checks your site every week (speed, TLS, broken links, core metrics) - OpenAI turns that into a 1–2 page plain-English brief + a short task list - You get it the same morning every week, no dashboards required If you send me your domain, I can run a one-time brief so you can see whether this would actually be useful for you.
