How to Create an SEO Content Brief from Google's Top 10 (with Python)
Michael Carter · · 25 min read

Key takeaways
- An SEO content brief can be built from evidence: Google's top 10 from a SERP API, the ranking pages fetched by your own polite script, and their headings and word counts summarized into subtopics, title patterns and a length range.
- A SERP API returns results, not page text. Headings and lengths come from fetching each ranking page yourself, so the script must obey robots.txt, name itself in its User-Agent and wait at least a second between requests to a host.
- For "how to create a content calendar" in the US on November 18, 2026, the script read 6 of 7 results: median 1,796 words, median 6 H2 sections, and 4 of 7 titles adding the word "social".
- How much of page one a script can read depends on the keyword: 6 of 7 results for a content calendar guide, 5 of 8 for a press release guide, and 1 of 8 for a cold brew recipe, where videos and social posts filled page one.
- Use a language model to critique a brief, not to write the article: keep every number from your own data, and remember Google says it has no preferred word count.
An SEO content brief is the one-page plan a writer gets before drafting: the search intent, the subtopics to cover, the questions to answer and a sensible length. You can build it from evidence: collect Google's top 10 for the keyword, fetch the ranking pages politely, extract their headings and word counts, and summarize what they share.
This tutorial is for SEO leads, content strategists and developers of SEO tools. You get a tested Python script that turns one keyword into a Markdown brief for one search credit, and its results on three real keywords from November 18, 2026, including one where the method fails, and why.
What should an SEO content brief include?
An SEO content brief gives the writer what the search rewards and what the piece must add. Most fields can be measured; one cannot.
| Field | What it tells the writer | Where the evidence comes from |
|---|---|---|
| Keyword and market | The query, country and language | You |
| Search intent and format | Guide, list, video, template? | Result types and titles in the top 10 |
| Title patterns | Words and formats the titles share | Titles in the top 10 |
| Length and structure | A sensible range and a typical number of sections | The ranking pages |
| Subtopics, in order | What a complete answer covers | Headings of the ranking pages |
| Questions | What readers ask | Question headings |
| Pages analyzed | What you compete with | The top 10, measured |
| Angle | What only you can add | You, by hand |
Search intent and format come from reading the results page itself, which our guide to SERP analysis covers; this tutorial automates the page-level part. The last row is the one a script cannot fill, and it decides whether the page deserves to rank. Google's guidance on creating helpful, people-first content asks "Does the content provide original information, reporting, research, or analysis?" and warns against "mainly summarizing what others have to say without adding much value". A brief built from competitors' headings shows the baseline; your angle is how you get above it.
What you will build
The script takes a keyword, a country and a language, and writes four files: the results (serp.json), the measurements of each ranking page (pages.json, headings and counts only, no page text), the brief (brief.md), and a prompt for an optional AI review (llm-prompt.txt). This is the SEO content brief it wrote for "how to create a content calendar" in the US:

Every number comes from data: results and titles from the search, lengths and headings from the pages. "For the writer" stays empty on purpose.
What you need
- Python 3 with
requestsandbeautifulsoup4(pip install requests beautifulsoup4). We tested on November 18, 2026 with Python 3.12.10, requests 2.34.2 and beautifulsoup4 4.15.0. - A BestSERP API key in the
BESTSERP_API_KEYenvironment variable. BestSERP (bestserp.com), the Google SERP API we run, gives 3,000 free searches, then $0.50 per 1,000. The quickstart shows a first request, and our guide to Google search results in Python covers the basics.
One fact shapes the design: a SERP API returns results, not page text. Each result has a position, title, link, snippet and domain. The headings and lengths come from your own code visiting each ranking page, which makes your script a small crawler, so it should be a polite one:
- obey robots.txt;
- name itself in the User-Agent header, with no personal data;
- send at most one request per second to each host;
- use timeouts, and skip pages that fail or block, saying why;
- never fetch Google pages;
- keep headings and counts, not the pages' text.
Beautiful Soup, "a Python library for pulling data out of HTML and XML files", does the parsing with Python's built-in html.parser. Paste the code blocks below into one file, content_brief.py, in the order shown.
Step 1: Collect Google's top 10
The first function asks BestSERP for the top 10 and waits until every result link is a final URL, because the next step visits those URLs.
"""SEO content brief from Google's top 10: collect the results with BestSERP, fetch the ranking pages politely,
extract their headings and lengths, find shared subtopics and title patterns, and write a Markdown brief.
export BESTSERP_API_KEY=... # never hard-code the key
python content_brief.py "how to write a press release" --gl us --hl en --out briefs
Tested 2026-11-18 with Python 3.12.10, requests 2.34.2 and beautifulsoup4 4.15.0.
One keyword costs 1 search (1 credit). The API returns results, not page text: this script fetches the pages itself,
obeys robots.txt, waits at least 1 second between requests to a host, and skips pages that fail or block.
"""
import argparse
import json
import os
import re
import statistics
import time
from collections import Counter, defaultdict
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import urljoin, urlparse
from urllib.robotparser import RobotFileParser
import requests
from bs4 import BeautifulSoup
API = "https://api.bestserp.com"
HEADERS = {"X-API-KEY": os.environ.get("BESTSERP_API_KEY", "")}
UA = "BestSERP-blog-content-brief/1.0 (+https://bestserp.com/blog)" # name your script; no personal data
# Step 1: collect the top 10 ------------------------------------------------------------------------------------------
def fetch_serp(q, gl, hl):
"""Google's top 10 for one keyword, with final links. Polls 202 and linksPending; retries 429/502/503."""
body = {"q": q, "gl": gl, "hl": hl, "num": 10}
for attempt in range(5):
r = requests.post(f"{API}/search", headers=HEADERS, json=body, timeout=130)
if r.status_code not in (429, 502, 503):
break
time.sleep(int(r.headers.get("Retry-After", 10 * (attempt + 1)))) # never charged, or refunded
r.raise_for_status() # 400, 401, 402: fix the request, do not retry
serp = r.json()
deadline = time.time() + 180
# 202: the search is still running. linksPending: some links are still Google redirects.
while (r.status_code == 202 or serp.get("linksPending")) and time.time() < deadline:
time.sleep(5)
r = requests.get(f"{API}/requests/{serp['requestId']}", headers=HEADERS, timeout=130)
r.raise_for_status()
serp = r.json()
serp["fetchedAt"] = datetime.now(timezone.utc).isoformat(timespec="seconds")
if serp.get("ipCountry", gl).lower() != gl.lower():
print(f"warning: the search ran from an IP in {serp['ipCountry']}, not {gl}: run it again later")
return serp
One keyword is one search (num: 10, 1 credit). A 429 waits for Retry-After, a 502 or 503 is retried (both are refunded), and 400 to 402 stop the script, because retrying cannot fix them.
The polling loop matters here. Google serves some result links as redirects; BestSERP answers first and replaces them with final URLs in the background, so the code polls /requests/{requestId} until linksPending is false (see link resolution). In our runs the answer took 4.9 to 6.0 seconds (durationMs), the final links arrived about 29 to 42 seconds after the request, and no link stayed a redirect.
The ipCountry check guards the market. A search runs from an IP in the gl country when one is free and from another country otherwise, and ipCountry says which; a US brief built from results gathered elsewhere describes the wrong market. All three of our searches ran from US IPs.
Step 2: Fetch and parse the ranking pages
Step 2 visits each result with your own HTTP client: robots.txt first, then the page, with a pause between requests to the same host.
last_hit = {} # host -> time of our last request to it
robots = {} # host -> (RobotFileParser, reason to give when it refuses)
def polite_get(url, delay=1.0, follow=False):
"""GET with our User-Agent and timeouts, at least `delay` seconds after our last request to the same host."""
host = urlparse(url).netloc
wait = last_hit.get(host, 0) + delay - time.time()
if wait > 0:
time.sleep(wait)
last_hit[host] = time.time()
return requests.get(url, headers={"User-Agent": UA}, timeout=(5, 20), allow_redirects=follow)
def robots_for(url):
"""(rules, reason to give when they refuse) from the host's robots.txt. 4xx: no rules (RFC 9309); 5xx or no
answer: disallow everything; 401/403: disallow everything, as Python's RobotFileParser.read() does."""
parts = urlparse(url)
if parts.netloc not in robots:
rp, why = RobotFileParser(), "robots.txt disallows this URL"
try:
r = polite_get(f"{parts.scheme}://{parts.netloc}/robots.txt", follow=True)
if r.status_code == 200:
rp.parse(r.text.splitlines())
elif r.status_code in (401, 403) or r.status_code >= 500:
rp.disallow_all, why = True, f"robots.txt answered HTTP {r.status_code}"
else:
rp.allow_all = True
except requests.RequestException as e:
rp.disallow_all, why = True, f"robots.txt unreachable ({type(e).__name__})"
robots[parts.netloc] = (rp, why)
return robots[parts.netloc]
def fetch_page(url, max_redirects=3):
"""(HTML bytes, final URL) for one ranking page, or (None, the reason we skipped it)."""
for _ in range(max_redirects + 1):
host = urlparse(url).netloc.lower()
if "google." in host:
return None, "Google page or redirect (never fetched)"
if host.endswith("youtube.com"):
return None, "video page"
rp, why = robots_for(url)
if not rp.can_fetch(UA, url):
return None, why
try:
r = polite_get(url, delay=max(1.0, float(rp.crawl_delay(UA) or 0)))
except requests.RequestException as e:
return None, f"network error ({type(e).__name__})"
if r.is_redirect: # follow by hand so robots.txt is checked for every hop
url = urljoin(url, r.headers["Location"])
continue
if r.status_code != 200:
return None, f"HTTP {r.status_code}"
if "html" not in r.headers.get("Content-Type", ""):
return None, "not HTML"
return r.content, url
return None, "too many redirects"
Python's urllib.robotparser "answers questions about whether or not a particular user agent can fetch a URL". We download robots.txt with requests and call parse() instead of read(), so our User-Agent and timeout apply. Missing files follow RFC 9309: a 4xx answer means no rules ("the crawler MAY access any resources on the server"), while a server error or no answer means "the crawler MUST assume complete disallow". A 401 or 403 counts as disallow, as Python's own read() treats it. Redirects are followed by hand so every hop is checked, and a longer Crawl-delay is honored.
Parsing keeps the shape of the page and throws the text away:
NOISE = ["script", "style", "noscript", "svg", "nav", "header", "footer", "aside", "form", "iframe"]
BOILERPLATE = re.compile(r"(related (posts|articles|reading|resources)|you may also like|recent posts|popular posts|top posts|"
r"other articles|more articles|blog posts by|join|subscribe|sign up|share this|leave a (reply|comment)|"
r"\d* ?comments?$|about the author|table of contents|contents$|in this (article|post|guide))", re.I)
def parse_page(html):
"""Title, H1, H2/H3 headings, word count and formats of the page's main content (no body text is kept)."""
soup = BeautifulSoup(html, "html.parser")
title = soup.title.get_text(" ", strip=True) if soup.title else ""
h1 = soup.find("h1")
h1 = h1.get_text(" ", strip=True) if h1 else ""
for tag in soup(NOISE):
tag.decompose()
candidates = soup.find_all(["article", "main"]) or [soup.body or soup]
root = max(candidates, key=lambda t: len(t.get_text(" ", strip=True))) # the biggest article or main block
headings = []
for h in root.find_all(["h2", "h3"]):
text = " ".join(h.get_text(" ", strip=True).split())
if text and len(text) <= 150 and not BOILERPLATE.match(text):
headings.append({"level": h.name, "text": text})
return {"title": title, "h1": h1, "words": len(re.findall(r"\w[\w'’-]*", root.get_text(" ", strip=True))),
"headings": headings, "h2": sum(h["level"] == "h2" for h in headings),
"tables": len(root.find_all("table")), "ordered_lists": len(root.find_all("ol")),
"images": len(root.find_all("img"))}
Navigation, headers, footers, sidebars and forms go first; the biggest <article> or <main> block is the main content. H2 and H3 headings are kept unless they are boilerplate such as "Related posts". Pages with fewer than 200 words in their HTML are skipped later as probable JavaScript pages: requests does not run JavaScript.
Step 3: Find common subtopics, headings and lengths
A word that appears in the headings of at least 30% of the analyzed pages (and at least two) counts as a shared subtopic. Its median place in those pages, from 0 at the top to 1 at the end, suggests where it belongs in your outline.
STOP = set("""a about all also an and are as at be before by can do does don't for from has have here how i if in into is it
its just like many more most much my new not now of off on one or other our out over should so than that the their them
then there these they this to up very vs was we what when where which who why will with you your faq faqs frequently
asked question questions introduction conclusion final thoughts takeaways key best top guide step steps tip tips way
ways""".split())
def stem(w):
"""Crude stem, so that "schedule", "schedules" and "scheduling" count as one word."""
if len(w) > 5 and w.endswith("ing"):
w = w[:-3]
w = w[:-1] if w[-1] == w[-2] else w # planning -> plan
elif len(w) > 3 and w.endswith("s") and not w.endswith(("ss", "is", "us")):
w = w[:-1] # headlines -> headline
return w[:-1] if len(w) > 3 and w.endswith("e") else w
# Verbs that start many headings ("Create a ...", "Identify your ...") but name no subtopic.
GENERIC = {stem(w) for w in """add build choose create decide define determine do find get give go help identify keep let
make need pick put set start stay stick take try understand use know""".split()}
def subtopics(pages, keyword):
"""Heading words used by at least 30% of the pages (min 2), with their median place in the page (0 top, 1 end)."""
drop = {stem(w) for w in re.findall(r"[a-z][a-z'-]+", keyword.lower())} # the keyword's own words
seen, forms = defaultdict(dict), defaultdict(Counter) # term -> {url: (place, heading)}; term -> word forms
for p in pages:
n = len(p["headings"])
for i, h in enumerate(p["headings"]):
for w in re.findall(r"[a-z][a-z'-]+", h["text"].lower()):
t = stem(w)
if w in STOP or t in GENERIC or t in drop or len(t) < 3:
continue
forms[t][w] += 1
seen[t].setdefault(p["url"], (i / max(n - 1, 1), h["text"]))
need = max(2, round(0.3 * len(pages)))
rows = [{"term": forms[t].most_common(1)[0][0], "pages": len(by), "place": statistics.median(x for x, _ in by.values()),
"examples": [h for _, h in by.values()]} for t, by in seen.items() if len(by) >= need]
return sorted(rows, key=lambda r: (-r["pages"], r["place"]))
The keyword's own words are dropped (every heading on a content calendar page says "content calendar"), and so are stop words and verbs that start headings without naming anything, such as "create" or "identify". The stemmer is deliberately crude: it folds "schedule", "schedules" and "scheduling" into one subtopic, and the brief shows each subtopic in its most common spelling.
Questions, title patterns and dates need a few more lines:
QUESTION = re.compile(r"^(what|why|when|which|who|where|how (?!to\b))\b.+|.+\?$", re.I) # "How to ..." is a step
def questions(pages):
"""Question headings as (text, number of pages that use it)."""
found, text = defaultdict(set), {}
for p in pages:
for h in p["headings"]:
if QUESTION.match(h["text"]):
key = h["text"].rstrip("?").strip().lower()
text.setdefault(key, h["text"].rstrip("?").strip())
found[key].add(p["url"])
return sorted(((text[k], len(urls)) for k, urls in found.items()), key=lambda x: -x[1])
TITLE_PATTERNS = {"a year": r"\b20\d\d\b", "a number": r"\b(?!20\d\d\b)\d+\b", "template": r"templat",
"example": r"exampl", "guide": r"\bguide", "step": r"\bsteps?\b", "free": r"\bfree\b"}
def title_patterns(serp, keyword):
"""How many titles use the keyword and each pattern, and the words titles add to the keyword (2+ titles)."""
titles = [r["title"] for r in serp.get("organic", [])]
found = {"the exact keyword": sum(keyword.lower() in t.lower() for t in titles)}
found.update({name: sum(bool(re.search(rx, t, re.I)) for t in titles) for name, rx in TITLE_PATTERNS.items()})
drop = {stem(w) for w in re.findall(r"[a-z][a-z'-]+", keyword.lower())}
added = Counter(w for t in titles for w in set(re.findall(r"[a-z][a-z'-]+", t.lower()))
if w not in STOP and stem(w) not in drop and len(w) > 2)
return found, len(titles), [(w, n) for w, n in added.most_common(6) if n >= 2]
def snippet_dates(serp):
"""Dates Google shows at the start of snippets ("Nov 29, 2023 — ...")."""
out = []
for r in serp.get("organic", []):
m = re.match(r"([A-Z][a-z]{2} \d{1,2}, \d{4})", r.get("snippet", ""))
if m:
out.append(datetime.strptime(m.group(1), "%b %d, %Y").date())
return sorted(out)
The brief reports length as a range: the median and the middle half, never the longest page, because one long outlier would set an absurd target. Google says so directly: "Are you writing to a particular word count because you've heard or read that Google has a preferred word count? (No, we don't.)"
Step 4: Generate the SEO content brief
The last function turns the measurements into Markdown:
def fmt(n):
return f"{n:,.0f}"
def result_kind(item):
site = (item.get("domain") or item.get("source", "")).lower()
if re.search(r"youtube|vimeo|tiktok", site):
return "videos"
if re.search(r"reddit|quora|facebook|linkedin|pinterest|instagram", site):
return "social or forum posts"
return "web pages"
def write_brief(q, gl, hl, serp, pages, skipped):
words = sorted(p["words"] for p in pages)
h2s = sorted(p["h2"] for p in pages)
q1, _, q3 = statistics.quantiles(words, n=4) if len(words) > 1 else (words[0], 0, words[0])
found, n_titles, added = title_patterns(serp, q)
dates = snippet_dates(serp)
topics = subtopics(pages, q)
when = datetime.fromisoformat(serp["fetchedAt"]).strftime("%Y-%m-%d %H:%M UTC")
kinds = Counter(result_kind(r) for r in serp.get("organic", []))
out = [f"# SEO content brief: {q}", "",
f"Market: gl={gl}, hl={hl} (search ran from {serp.get('ipCountry', 'unknown')}). Google results collected "
f"{when}. {len(serp.get('organic', []))} organic results; {len(pages)} pages analyzed, {len(skipped)} skipped.", "",
"## Search intent and format",
"- Result types: " + ", ".join(f"{n} {k}" for k, n in kinds.most_common())
+ (f"; a video carousel with {len(serp['videos'])} videos" if serp.get("videos") else "")
+ (f"; Top stories with {len(serp['news'])} articles" if serp.get("news") else "") + ".",
"- Titles that use: " + ", ".join(f"{k} {v}/{n_titles}" for k, v in found.items() if v) + ".",
"- Words titles add to the keyword: " + (", ".join(f"{w} {n}/{n_titles}" for w, n in added) or "none") + ".",
f"- Dated snippets: {len(dates)} of {n_titles}" + (f", from {dates[0]:%b %Y} to {dates[-1]:%b %Y}." if dates else "."),
"", "## Length and structure",
f"- Words in the main content: median {fmt(statistics.median(words))}, middle half {fmt(q1)} to {fmt(q3)}, "
f"range {fmt(words[0])} to {fmt(words[-1])}.",
f"- H2 sections: median {statistics.median(h2s):g} (range {h2s[0]} to {h2s[-1]}). "
f"Pages with a table: {sum(p['tables'] > 0 for p in pages)}/{len(pages)}; "
f"with a numbered list: {sum(p['ordered_lists'] > 0 for p in pages)}/{len(pages)}.",
"- Google has no preferred word count: cover the subtopics below, then stop.", ""]
if len(pages) < 5:
out += [f"> Only {len(pages)} of {len(serp['organic'])} results could be analyzed: too few for a reliable brief. "
"Read this SERP by hand.", ""]
out += ["## Subtopics the ranking pages share (suggested order)", "| Subtopic | Pages | Example heading |", "|---|---|---|"]
for t in sorted(topics[:12], key=lambda r: r["place"]):
example = t["examples"][0] if len(t["examples"][0]) <= 70 else t["examples"][0][:68].rstrip() + "…"
out.append(f"| {t['term']} | {t['pages']}/{len(pages)} | {example} |")
qs = questions(pages)[:8]
if qs:
out += ["", "## Questions in their headings"] + [f"- {q_}? ({n} page{'s' * (n > 1)})" for q_, n in qs]
out += ["", "## Pages analyzed", "| # | Site | Words | H2 |", "|---|---|---|---|"]
rows = [(p["position"], f"| {p['position']} | {p['domain']} | {fmt(p['words'])} | {p['h2']} |") for p in pages]
rows += [(s["position"], f"| {s['position']} | {s['domain']} | skipped: {s['reason']} | |") for s in skipped]
out += [row for _, row in sorted(rows)]
out += ["", "## For the writer (fill in by hand)", "- Angle: what can we add that none of these pages has "
"(our own data, tests, examples, experience)?", "- Audience and goal:", "- Internal links:", ""]
return "\n".join(out)
And the entry point, with the prompt for the AI review covered below:
def llm_prompt(brief_md):
"""A prompt that asks a language model to critique the brief, not to write the article."""
return ("You are helping an SEO editor check a content brief. It was built from the headings and lengths of the "
"pages that rank in Google for the keyword. List up to 5 subtopics or reader questions it misses, and "
"say which listed subtopics look like noise. Do not write the article. Do not invent statistics.\n\n"
+ brief_md)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("keyword")
ap.add_argument("--gl", default="us")
ap.add_argument("--hl", default="en")
ap.add_argument("--out", default="briefs")
a = ap.parse_args()
folder = Path(a.out, re.sub(r"[^a-z0-9]+", "-", a.keyword.lower()).strip("-"))
folder.mkdir(parents=True, exist_ok=True)
serp_file = folder / "serp.json"
if serp_file.exists(): # re-running the analysis costs nothing
serp = json.loads(serp_file.read_text(encoding="utf-8"))
else:
serp = fetch_serp(a.keyword, a.gl, a.hl)
serp_file.write_text(json.dumps(serp, indent=1, ensure_ascii=False), encoding="utf-8")
pages, skipped = [], []
for item in serp.get("organic", []):
info = {"position": item["position"], "domain": item.get("domain") or item.get("source", "?"), "link": item["link"]}
html, final = fetch_page(item["link"])
page = parse_page(html) if html else None
if page and page["words"] < 200:
html, final = None, "under 200 words in the HTML (JavaScript page?)"
if html is None:
skipped.append({**info, "reason": final})
print(f"{item['position']:>2} {info['domain']}: skipped, {final}")
continue
pages.append({**info, "url": final, **page})
print(f"{item['position']:>2} {info['domain']}: {page['words']} words, {page['h2']} H2")
(folder / "pages.json").write_text(json.dumps({"pages": pages, "skipped": skipped}, indent=1, ensure_ascii=False),
encoding="utf-8")
if not pages:
raise SystemExit("no ranking page could be analyzed: see the reasons above")
brief = write_brief(a.keyword, a.gl, a.hl, serp, pages, skipped)
(folder / "brief.md").write_text(brief, encoding="utf-8")
(folder / "llm-prompt.txt").write_text(llm_prompt(brief), encoding="utf-8")
print(f"{len(pages)} pages analyzed, {len(skipped)} skipped -> {folder / 'brief.md'}")
if __name__ == "__main__":
main()
Run it with your key in the environment:
export BESTSERP_API_KEY=YOUR_API_KEY
python content_brief.py "how to create a content calendar" --gl us --hl en --out data/briefs
1 edifycontent.com: 1035 words, 7 H2
2 nancycasanova.com: 1675 words, 3 H2
3 socialmediatoday.com: 1056 words, 9 H2
4 virtualateam.com: 2068 words, 4 H2
5 zerys.com: 9432 words, 8 H2
6 pinterest.com: skipped, robots.txt disallows this URL
7 jennstrends.com: 1917 words, 5 H2
6 pages analyzed, 1 skipped -> data\briefs\how-to-create-a-content-calendar\brief.md
The page step took 19 seconds, mostly the one-second pauses. Here is the SEO content brief it wrote, in full:
# SEO content brief: how to create a content calendar
Market: gl=us, hl=en (search ran from us). Google results collected 2026-11-18 06:56 UTC. 7 organic results; 6 pages analyzed, 1 skipped.
## Search intent and format
- Result types: 6 web pages, 1 social or forum posts; a video carousel with 4 videos.
- Titles that use: the exact keyword 2/7, a number 1/7.
- Words titles add to the keyword: social 4/7, media 3/7.
- Dated snippets: 3 of 7, from Jan 2017 to Jun 2026.
## Length and structure
- Words in the main content: median 1,796, middle half 1,051 to 3,909, range 1,035 to 9,432.
- H2 sections: median 6 (range 3 to 9). Pages with a table: 0/6; with a numbered list: 1/6.
- Google has no preferred word count: cover the subtopics below, then stop.
## Subtopics the ranking pages share (suggested order)
| Subtopic | Pages | Example heading |
|---|---|---|
| goals | 3/6 | Live Your Best Life With Content Marketing Goals |
| blog | 3/6 | Should I Start a Blog? |
| themes | 2/6 | Identify Main Content Themes |
| organize | 2/6 | 4. Organize Your Writers and Contributors |
| plan | 2/6 | Define Your Strategy and Goals Before You Start Planning Your Conten… |
| strategy | 2/6 | 2. Build a Content Strategy |
| writers | 2/6 | 4. Organize Your Writers and Contributors |
| include | 2/6 | What to Include In Your Content Calendar |
| type | 2/6 | 5. Asset Type |
| schedule | 4/6 | 3. Create a Schedule |
| date | 3/6 | 6. Do Date and Due Date |
| posting | 3/6 | Decide What Networks You'll Be Posting To |
## Questions in their headings
- Should I Start a Blog? (1 page)
- What to Include In Your Content Calendar? (1 page)
- How do I build a content calendar? (1 page)
- How often should I populate my content calendar? (1 page)
- How can I be more consistent with content creation? (1 page)
- Why We Need Social Media Content Calendars? (1 page)
- How Content Calendars Can Help Blogs and Social Media Grow? (1 page)
- Why Do You Need a Content Calendar? (1 page)
## Pages analyzed
| # | Site | Words | H2 |
|---|---|---|---|
| 1 | edifycontent.com | 1,035 | 7 |
| 2 | nancycasanova.com | 1,675 | 3 |
| 3 | socialmediatoday.com | 1,056 | 9 |
| 4 | virtualateam.com | 2,068 | 4 |
| 5 | zerys.com | 9,432 | 8 |
| 6 | pinterest.com | skipped: robots.txt disallows this URL | |
| 7 | jennstrends.com | 1,917 | 5 |
## For the writer (fill in by hand)
- Angle: what can we add that none of these pages has (our own data, tests, examples, experience)?
- Audience and goal:
- Internal links:
How to read this brief
In an SEO content brief like this one, treat rows found on half the pages or more as the core and rows at 2 of 6 as candidates. Here the core is the schedule (4 of 6 pages), then goals, blog, dates and posting (3 of 6 each). Sorted by where they sit, the outline runs from goals and themes, through strategy and the schedule, to dates and posting.
The title line carries the main decision: 4 of 7 titles add "social", so the results mix social media and blog calendars, and your page should pick one or cover both on purpose. About 1,800 words is normal here; the 9,432-word page is an outlier that does not move the median. The oldest dated snippet is from January 2017, which leaves room for a current guide.

What the brief cannot say is what to add. It shows what the ranking pages cover, not what readers still miss: your own numbers, a template you have tested, a worked example from your team. That is the angle, and it comes from you.
What three real keywords showed
The same script produced a usable brief, a thin one and a warning, because the share of page one a polite script can read depends on the keyword.

- "how to create a content calendar": 6 of 7 read. Only Pinterest was skipped: its robots.txt disallows crawlers it has not allowlisted.
- "how to write a press release": 5 of 8 read. One result was a YouTube video, and two hosts (PR Newswire and Medium) were blocked by our test machine's own network settings, not by the sites, so the script counted their robots.txt as unreachable; from an ordinary connection they may be readable. The five pages share the classic structure: headline, body paragraphs, boilerplate and contact details (2 of 5 pages each).
- "how to make cold brew coffee": 1 of 8 read. Page one held two Facebook posts (robots.txt disallows), three YouTube videos plus a four-video carousel, and two grocery-chain recipe pages whose servers refused even robots.txt with HTTP 403. The brief warns "Only 1 of 8 results could be analyzed", and that is a finding in itself: Google answers this query with videos and social posts, so a long article is probably the wrong format.
Method. BestSERP /search, gl=us, hl=en, num=10, one search per keyword between 06:53 and 06:57 UTC on November 18, 2026; ipCountry was us for all three, with 7 or 8 organic results each. The script fetched the pages at 07:05 UTC from the saved serp.json files. Of the 23 results, 12 were read and 11 skipped: 4 videos, 3 robots.txt disallows, 2 robots.txt answered 403, 2 hosts blocked by our test network. A fourth keyword tried while choosing examples, "employee onboarding checklist", gave 5 of 8.
Using AI responsibly for briefs
Use a language model to critique the SEO content brief, not to replace the evidence or to write the article. llm_prompt() wraps the brief in this instruction and saves it as llm-prompt.txt:
You are helping an SEO editor check a content brief. It was built from the headings and lengths of the pages
that rank in Google for the keyword. List up to 5 subtopics or reader questions it misses, and say which listed
subtopics look like noise. Do not write the article. Do not invent statistics.
We did not run a model for this post: there is no language-model API key on our test machine, so there is no model output to show. To use it, paste the file into the chat assistant you already use, or send it as the user message through your provider's SDK. Three rules keep the step honest:
- Numbers come from the script, never from the model. If an answer adds a statistic, delete it or find its source.
- The model proposes; an editor decides. Check every suggested subtopic against the results page before it goes into the outline.
- The brief holds other sites' headings. Treat them as untrusted input: a heading can contain text written to steer a model, so the model's answer is a suggestion, never an action.
Google's helpful content guidance lists "Are you using extensive automation to produce content on many topics?" among the signs of search-engine-first content. A model that helps check a brief is not that; a model that writes the articles from briefs, with no editor's own knowledge added, is. To feed whole pages to a model rather than headings, see RAG with web search.
Handling errors and limits
Most failures come from the pages, not the API:
| Problem | Cause | Fix |
|---|---|---|
429 rate_limited |
More than 60 searches a minute (the default per account) | The script waits Retry-After; batch large keyword lists |
502 or 503 |
The search failed or the system was busy | Retried automatically; refunded, never charged |
| Warning: the search ran from another country | No free IP in the gl country at that moment |
Run it again later; do not mix markets in one brief |
| A result skipped as a Google page | A link was still a redirect when polling stopped | Run again later; never fetch the redirect |
| Many "robots.txt disallows" skips | The site forbids crawlers it has not named | Respect it, and read those pages in a browser |
| "under 200 words in the HTML" | The page builds its text with JavaScript | Read it by hand; a headless browser is a separate decision |
| A site answers 403 or 429 | Bot protection | Skip it; do not disguise the script as a browser |
| Subtopics full of filler words | Few pages, or boilerplate headings | Add words to STOP or BOILERPLATE; trust briefs built on 5 pages or more |
On cost: an identical search within an hour is served from cache at the normal price. The script's own cache is serp.json: delete the folder for fresh results, keep it to re-run the analysis for free. At 1 credit a keyword, the 3,000 free searches cover 3,000 briefs.
Next steps
- Read the results page before you brief: SERP analysis before you write.
- Find which sites hold the top 10 across a whole keyword set: SERP competitor analysis.
- Check the title and meta description you write from the brief against the real top 10 in the SERP Simulator; more SEO workflows are on the SEO tools use case page.