DEV Community: Level Up Digital Marketing Group

Pipe Search Console Into Claude: A Small Node Script That Writes Your Weekly SEO Brief

Level Up Digital Marketing Group — Mon, 05 Oct 2026 17:41:38 +0000

Most developers who own a marketing site check Search Console the same way: open it, click around for ten minutes, close it, forget what you saw. The data is good. The habit is bad. The fix is a script that pulls the last few weeks of numbers, compares the most recent window to the one before it, and hands the deltas to a model that writes three paragraphs you will actually read on Monday morning.

Here is the whole thing. It runs on a cron, costs very little, and has nothing to do with dashboards.

What the script does

Query the Search Console API for the last 28 days of clicks and impressions, split by query and by page.
Split that into two 14 day windows and compute the change per query and per page.
Sort the biggest movers in both directions.
Send the movers to Claude with a short, strict prompt.
Put the result wherever you read things: Slack, email, a Notion page, a text file.

The model is not analyzing the raw data. It is turning a sorted list of changes into sentences. That distinction keeps the output grounded and keeps the token bill small.

Why two windows instead of a plain weekly total? A total tells you the site got 412 clicks. It does not tell you that one page gained 90 and another lost 110, which is the only part worth your attention. Comparing like for like periods surfaces movement, and movement is what you can act on.

Setup

You need a Google Cloud service account with the Search Console API enabled, added as a user on the property in Search Console (Settings, then Users and permissions; Full or Restricted both work for reads). Download the JSON key. Set three environment variables:

GOOGLE_APPLICATION_CREDENTIALS=./sc-key.json
SC_SITE_URL=sc-domain:example.com
ANTHROPIC_API_KEY=sk-ant-...

Use the sc-domain: form if your property is a domain property, or the full https://www.example.com/ URL if it is a URL prefix property. Install two packages:

npm install googleapis @anthropic-ai/sdk

Pulling the data

// gsc.js
import { google } from 'googleapis';

const auth = new google.auth.GoogleAuth({
  scopes: ['https://www.googleapis.com/auth/webmasters.readonly'],
});
const sc = google.searchconsole({ version: 'v1', auth });

export async function fetchRows(startDate, endDate, dimension) {
  const res = await sc.searchanalytics.query({
    siteUrl: process.env.SC_SITE_URL,
    requestBody: {
      startDate,
      endDate,
      dimensions: [dimension],
      rowLimit: 1000,
    },
  });
  return (res.data.rows || []).map((r) => ({
    key: r.keys[0],
    clicks: r.clicks,
    impressions: r.impressions,
    position: r.position,
  }));
}

Search Console data lags by a couple of days, so do not end the window at today. End it three days back and nobody will chase a phantom drop.

If the first call returns a 403, the service account email has not been added to the property yet, or you added it to the wrong property type. The domain property and the URL prefix property are separate entries in Search Console with separate user lists. Run sc.sites.list() once and the response tells you exactly which properties the account can see.

Computing the movers

// compare.js
export function diff(current, previous, limit = 15) {
  const prev = new Map(previous.map((r) => [r.key, r]));
  const rows = current.map((r) => {
    const p = prev.get(r.key) || { clicks: 0, impressions: 0, position: null };
    return {
      key: r.key,
      clicks: r.clicks,
      clicksDelta: r.clicks - p.clicks,
      impressions: r.impressions,
      impressionsDelta: r.impressions - p.impressions,
      position: r.position.toFixed(1),
      prevPosition: p.position ? p.position.toFixed(1) : null,
    };
  });
  const up = [...rows].sort((a, b) => b.clicksDelta - a.clicksDelta).slice(0, limit);
  const down = [...rows].sort((a, b) => a.clicksDelta - b.clicksDelta).slice(0, limit);
  return { up, down };
}

Pages that had traffic last period and none this period will not appear in current. If that matters to you, run the diff in both directions and flag keys that only exist in previous. For most small sites the top and bottom fifteen tell the story.

Writing the brief

// brief.js
import Anthropic from '@anthropic-ai/sdk';
import { fetchRows } from './gsc.js';
import { diff } from './compare.js';

const client = new Anthropic();

function iso(daysAgo) {
  const d = new Date();
  d.setDate(d.getDate() - daysAgo);
  return d.toISOString().slice(0, 10);
}

const [curQ, prevQ, curP, prevP] = await Promise.all([
  fetchRows(iso(16), iso(3), 'query'),
  fetchRows(iso(30), iso(17), 'query'),
  fetchRows(iso(16), iso(3), 'page'),
  fetchRows(iso(30), iso(17), 'page'),
]);

const data = { queries: diff(curQ, prevQ), pages: diff(curP, prevP) };

const prompt = `You are writing a weekly SEO brief for the owner of a small business website.
Use only the data below. Do not invent numbers. Do not speculate about causes you cannot see in the data.
Write three short paragraphs: what went up, what went down, and one thing worth checking this week.
Plain English, no bullet points, no headings.

${JSON.stringify(data, null, 2)}`;

const msg = await client.messages.create({
  model: process.env.CLAUDE_MODEL,
  max_tokens: 800,
  messages: [{ role: 'user', content: prompt }],
});

console.log(msg.content[0].text);

Set CLAUDE_MODEL to the current Sonnet model id from the Anthropic docs. Sonnet is more than enough for this. The input is a few thousand tokens of JSON and the output is three paragraphs.

Scheduling it

A GitHub Actions workflow on a Monday cron is the cheapest option if the repo already lives on GitHub. Store the secrets in the repository settings, write the service account JSON to disk in a step, and send the output wherever you want it.

# .github/workflows/seo-brief.yml
name: Weekly SEO brief
on:
  schedule:
    - cron: '0 14 * * 1'
  workflow_dispatch:
jobs:
  brief:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20 }
      - run: npm ci
      - run: echo "$SC_KEY_JSON" > sc-key.json
        env: { SC_KEY_JSON: ${{ secrets.SC_KEY_JSON }} }
      - run: node brief.js > brief.md
        env:
          GOOGLE_APPLICATION_CREDENTIALS: ./sc-key.json
          SC_SITE_URL: ${{ secrets.SC_SITE_URL }}
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          CLAUDE_MODEL: ${{ vars.CLAUDE_MODEL }}
      - uses: actions/upload-artifact@v4
        with: { name: seo-brief, path: brief.md }

Swap the artifact step for a Slack webhook or an email action once you trust the output. Keep workflow_dispatch in there so you can trigger a run by hand while you are tuning the prompt.

The prompt rules matter more than the model

Three constraints in that prompt do the real work. "Use only the data below" stops it from reaching for general SEO advice. "Do not speculate about causes" stops it from blaming an algorithm update it has no evidence for. "One thing worth checking" forces a single action instead of a to-do list nobody reads. Loosen those and the brief turns into content, and content is the thing you were trying to avoid reading.

Where this goes next

Once the brief lands every Monday, the same pattern extends. Pull GA4 landing page data next to the Search Console rows. Flag pages whose impressions rose while clicks did not, which usually points at the title tag. Diff against the same window last year for seasonal businesses. Each one is another fetch function and another field in the JSON. The model call does not change.

This is the smallest version of what we build when a business wants an in-house AI marketing system on Claude: plain code gathers the facts, the model writes the sentences, and a human reads three paragraphs instead of a dashboard.

Carlynn Espinoza runs Level Up Digital Marketing Group, a San Diego agency building SEO, paid media, and AI systems for service businesses.

Your React App Is Invisible to AI Crawlers. Here Is How to Check in Five Minutes

Level Up Digital Marketing Group — Mon, 28 Sep 2026 22:46:55 +0000

Most of the time when a client tells me "we are not showing up in ChatGPT," the site is a React app that renders everything on the client. The HTML that comes over the wire is a <div id="root"></div> and a script tag. A human with a browser sees a full page. A crawler that does not execute JavaScript sees nothing.

Google runs a rendering queue and will eventually execute your JavaScript. Most AI crawlers do not, or do it inconsistently. If you want to be cited by an AI assistant, the safest assumption is that the bot reads exactly what curl reads. Here is how to check, and what to change.

Step 1: Look at what the bot actually receives

Skip DevTools. DevTools shows you the DOM after hydration, which is not what a crawler gets. Use curl and pretend to be a bot.

curl -s -A "GPTBot" https://example.com/services/plumbing | head -c 3000

Now do the same with a few other user agents that matter right now:

for ua in "GPTBot" "ClaudeBot" "PerplexityBot" "Google-Extended" "Googlebot"; do
  echo "== $ua"
  curl -s -o /dev/null -w "%{http_code} %{size_download} bytes\n" -A "$ua" https://example.com/services/plumbing
done

Two things to read from the output. First, the status code: a 403 for one bot and a 200 for another means a WAF or bot rule is blocking you and you probably did not choose that. Second, the byte count: if the page is 1.8 KB for a bot and 90 KB in the browser, your content is not in the HTML.

Then grep the raw response for something that only exists in your real content, like a phone number or a service name:

curl -s -A "GPTBot" https://example.com/services/plumbing | grep -c "water heater"

Zero means the text is being injected by JavaScript after load. That is the whole problem in one number.

Step 2: Check robots.txt for accidental blocks

A lot of teams copied a robots.txt from a template in 2023 that blocked AI crawlers wholesale, and nobody revisited it. Pull it and look:

curl -s https://example.com/robots.txt

If you see User-agent: GPTBot followed by Disallow: /, you have opted out of being cited. That is a legitimate choice for some businesses. It is a bad choice for a local service company that wants referrals from AI assistants. Decide it on purpose, do not inherit it.

Also check the CDN layer. Cloudflare, Vercel, and others have toggles for AI bot blocking that override anything in your file. The curl status codes in step 1 will reveal that even when robots.txt looks clean.

Step 3: Render the important pages on the server

This is the fix, and in most modern frameworks it is a configuration change, not a rewrite.

In Next.js with the App Router, a page is a server component by default. If your service pages are client components because someone added "use client" at the top for a single interactive widget, move the widget into its own client component and keep the page itself on the server. The HTML will contain the full text on the first response.

// app/services/plumbing/page.tsx  (server component, no "use client")
import QuoteForm from "@/components/QuoteForm"; // this one is "use client"

export default async function PlumbingPage() {
  const data = await getServiceContent("plumbing");
  return (
    <main>
      <h1>{data.title}</h1>
      <p>{data.intro}</p>
      <QuoteForm />
    </main>
  );
}

If you are on Vite plus React with no server, you have three realistic options: prerender the static routes at build time (vite-plugin-ssr, Astro, or a simple prerender script with Playwright), move the marketing pages to a framework that renders on the server and leave the app where it is, or accept that those pages are invisible to non-rendering crawlers. The third one is fine for an authenticated dashboard. It is not fine for the pages you want customers to find.

When we take on a client site, the marketing pages are always server rendered from the start. We build them as static or server-rendered Next.js sites on Vercel, and it costs nothing extra at that scale. The dashboard behind login can be as client-heavy as it wants.

Step 4: Make sure the content is real HTML, not a JSON blob

Some sites technically ship the content in the initial response, but only inside a __NEXT_DATA__ or similar JSON script tag, with the visible markup still rendered client side. Crawlers vary in whether they read that. Do not depend on it. The test is simple: view the raw response and confirm the <h1>, the paragraphs, and the internal links exist as markup.

While you are there, confirm the links are real anchors with href attributes, not onClick handlers on divs. A crawler cannot follow a click handler.

Step 5: Recheck after every deploy

Put the curl checks in CI. A small script that fetches five key URLs as GPTBot, asserts a 200, and asserts that a known phrase exists in the raw body takes ten minutes to write and catches the regression where a developer wraps a layout in "use client" and silently blanks the site for every crawler.

#!/usr/bin/env bash
set -e
for url in "$@"; do
  body=$(curl -s -A "GPTBot" "$url")
  echo "$body" | grep -q "<h1" || { echo "FAIL no h1 in $url"; exit 1; }
  echo "$body" | grep -q "levelupdigitalmarketinggroup\|Call\|Contact" || { echo "FAIL no contact text in $url"; exit 1; }
  echo "ok $url"
done

The short version

Crawlers read source, not screens. Curl your pages as a bot, check the status and the byte count, grep for real content, fix the robots and CDN rules you forgot about, and render the pages that matter on the server. Everything else in AI search optimization sits on top of that, and none of it works if the bot receives an empty div.

Carlynn Espinoza runs Level Up Digital Marketing Group, a San Diego agency that builds and markets websites for local service businesses.

JSON-LD Structured Data: The Developer's Lever for SEO and AI Citations

Level Up Digital Marketing Group — Mon, 21 Sep 2026 21:33:31 +0000

Most SEO advice lands on marketers: write better copy, earn links, fix titles. But there's one high-leverage lever that lives entirely in the codebase, and developers own it outright: structured data.

Structured data (usually JSON-LD) is a small block of machine-readable JSON that tells search engines and AI answer engines exactly what an entity is, instead of making them infer it from prose. It's low effort, it's shippable in an afternoon, and it's increasingly how you get pulled into rich results and cited by AI. Here's the practical version.

What it actually is

JSON-LD is a <script type="application/ld+json"> block you drop in the <head> (or anywhere in the body). It follows the schema.org vocabulary. Nothing renders; it's purely a description for machines.

The minimum viable win for most businesses is an Organization (or LocalBusiness) block:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Acme Plumbing",
  "url": "https://acmeplumbing.com",
  "logo": "https://acmeplumbing.com/logo.png",
  "telephone": "+1-555-123-4567",
  "sameAs": [
    "https://www.linkedin.com/company/acme-plumbing",
    "https://www.g2.com/products/acme-plumbing"
  ]
}
</script>

That sameAs array matters more than it looks: it's how you connect your site to your other verified profiles, which helps engines resolve you as one trusted entity.

Why it matters more now

Two reasons. First, the classic one: rich results. Marked-up reviews, FAQs, breadcrumbs, and products can render enhanced listings that earn more clicks.

Second, the newer one: AI answer engines (ChatGPT, Google's AI Overviews, Perplexity) lean on clearly structured, trustworthy sources when they decide who to cite. Prose forces them to guess; JSON-LD hands them the facts in a format they don't have to interpret. If you want to be quotable by a model, being parseable is step one.

The three blocks worth shipping first

1. Article - on every blog/content page:

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to Winterize Your Pipes",
  "author": { "@type": "Organization", "name": "Acme Plumbing" },
  "datePublished": "2026-09-21",
  "image": "https://acmeplumbing.com/winterize.jpg"
}

2. BreadcrumbList - gives engines your site hierarchy and can render breadcrumb rich results:

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://acmeplumbing.com" },
    { "@type": "ListItem", "position": 2, "name": "Guides", "item": "https://acmeplumbing.com/guides" }
  ]
}

3. FAQPage - arguably the highest-ROI for AI citations, because it maps your content to explicit question/answer pairs:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "How much does emergency plumbing cost?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "Emergency call-outs typically run $150-$450 depending on the job and time of day."
    }
  }]
}

The gotchas that get people penalized

Mark up what's visible. The structured data must match the content a user actually sees on the page. FAQPage markup for questions that aren't on the page is a spam signal, not a shortcut.
Validate before you ship. Run every template through Google's Rich Results Test and the schema.org validator. A single malformed block can invalidate the whole thing.
One entity, consistent everywhere. Your name, URL, and phone in JSON-LD should match your site, your profiles, and your directory listings exactly. Conflicting data erodes the trust you're trying to build.
Generate it, don't hand-maintain it. In a component-based stack, render the JSON-LD from the same data source as the visible content so they never drift.

Why this is worth an afternoon

Structured data is one of the rare SEO tasks that is fully in a developer's control, ships once, and compounds: better rich-result eligibility and better odds of being cited by AI, from the same block of code. It won't rank a bad site, but on a decent site it's free leverage most competitors skip.

If you want the strategy layer that decides which pages and entities to prioritize on top of the technical implementation, that's what modern AI-native SEO is built to handle. But the JSON-LD itself? Ship it this week. Start with Organization and FAQPage.

Written by the team at Level Up Digital Marketing Group, an AI-native marketing agency helping established service businesses grow through SEO, ads, websites, and smarter use of AI. More at levelupdigitalmarketinggroup.com.