Analytics Integration - GSC Database
Your SEO tool queries Google's API every time you run an analysis. Wire doesn't. That difference compounds in ways that aren't obvious until you've hit a quota wall.
Wire pulls keyword data from Google Search Console and stores it in a local SQLite database. Every analysis, overlap check, and scoring run reads from that database, not from the API. This means the first command you run is always `python -m wire.chief data`. But before you run it, there's a question worth answering: do you have GSC authentication set up, or are you already past that and wondering why your numbers look wrong?
Wire uses Google OAuth, not an API key. That means the first run opens a browser window, you approve access, and a `token.json` file gets written to your project. If you're running Wire in a headless environment or CI, that browser step never happens and the command silently fails. The credentials live in your `.env` file. Two variables: `GOOGLE_CLIENT_ID` and `GOOGLE_CLIENT_SECRET`. Missing either one produces an auth error before Wire touches the API.
Running `python -m wire.chief data` fetches impressions, clicks, position, and CTR for every keyword every page ranks for, then writes it to three tables. The part that surprises most people: Wire skips pages with fresh data. If you fetched last week, this week's run does nothing for those pages unless you pass `--force`. That's intentional. But it means your database might be more stale than you think if you've been running without `--force` after making changes.
The database isn't just storage. Six separate functions run against it: overlap detection between pages sharing keywords, opportunity scoring for pages with high impressions and low CTR, content gap detection for queries no page ranks well for, dead page detection, keyword ownership to prevent the wrong page from being enriched, and trending keyword identification. Each function feeds a different Wire command. The complicating part: these functions share data, so the order you run commands in affects what each one sees.
Position one used to mean roughly 28% CTR. In 2026, for niche B2B sites, it's closer to 2.8%. AI Overviews intercept the query, answer it, and most users never scroll to organic results. Wire's opportunity scoring uses `impressions * (1 - CTR)` precisely because of this. A keyword with 500 impressions and 1% CTR scores 495. That's not a failure. That's 500 people who searched for your topic, most of whom got an AI summary instead of your page. The question is whether that's a reason to deprioritize the keyword or the opposite.
Wire's bet is that impression-weighted optimization outperforms click-weighted optimization over 6 to 12 months. The reasoning: AI Overviews are most active on the high-impression queries, and those overviews will change, fail, or lose user trust. Sites already ranking for those queries are positioned to capture the traffic when that happens. Sites that chased click-weighted keywords will have optimized for queries where AI Overviews were weakest, which are also the queries with the least total demand. That's a testable prediction, not a guarantee.
Most SEO tools query the API every time you run an analysis. Wire queries once, stores locally, and every subsequent command reads from SQLite. A SQL query takes milliseconds. An API call takes 2 to 5 seconds, plus rate limit pauses. Across 142 pages, that's the difference between under a second and over five minutes. The quota implication is sharper: Wire's API usage is fixed at one fetch cycle per topic. Every audit, deduplication run, and rewrite prioritization after that costs zero quota. The database file lives at `{site_dir}/.wire/gsc.db` and is gitignored by default.
Wire stores Google Search Console data in a local SQLite database. Every content decision (what to rewrite, what to merge, what to create) references this data. The database is the foundation that makes Wire's SEO automation possible.
How Data Gets In
python -m wire.chief data
python -m wire.chief data --force # Re-fetch even if data is fresh
The data command walks every topic in your site, lists every content page, and fetches keyword metrics from the GSC API. For each page, Wire stores impressions, clicks, average position, and CTR for every keyword the page ranks for.
Data is stored in three tables:
| Table | What it holds |
|---|---|
| Content | Page slug, topic, title. One row per page |
| Keyword | Keyword text, deduplicated across all pages |
| Snapshot | Page-keyword metrics: impressions, clicks, position, CTR, date |
Fresh data (under 28 days old) is skipped on the next run unless you pass --force. This prevents unnecessary API calls during frequent workflow runs.
What the Database Enables
Overlap Detection
find_overlaps() runs a SQL self-join on the Snapshot table to find page pairs sharing keywords. For each pair it computes shared keyword count, overlap ratio, traffic share, and total shared impressions.
The deduplication system uses these metrics to classify each overlap and decide whether to merge, differentiate, or ignore.
Opportunity Scoring
Every keyword is scored with impressions * (1 - CTR). A keyword with 500 impressions and 2% CTR scores 490, meaning high demand that your page is not capturing. The reword system uses these scores to prioritize which pages get rewritten first.
Content Gap Detection
find_content_gaps() finds keywords ranked by 3+ pages where no page ranks well (best position above 20) and no page slug matches the keyword. These represent search demand with no focused content.
Dead Page Detection
find_dead_pages() identifies pages with impressions below the site median threshold and older than 180 days. Combined with overlap data, Wire determines whether other pages already cover the dead page's keywords, making it safe to archive.
Keyword Ownership
keyword_ownership_batch() tells Wire which pages in a topic own specific keywords. This prevents the enrich pipeline from adding content to the wrong page when another page already ranks better for that keyword.
Trending Keywords
trending_keywords() finds the highest-impression keywords across all topics. This feeds into the weekly market report to ensure reports prioritize topics with actual search demand.
Database Location
The database lives at {site_dir}/.wire/gsc.db, in the site root, not in the Wire installation. Each site has its own database. The .wire/ directory is gitignored by default.
CTR in the AI Era
Traditional CTR benchmarks (position 1 = 28%, position 2 = 15%) are from before AI Overviews, ChatGPT Search, and Perplexity started intercepting search traffic. For niche B2B sites in 2026, real CTR is roughly one-tenth of published benchmarks.
| Position | Traditional CTR | AI-era CTR (2026) |
|---|---|---|
| 1 | 28% | 2.8% |
| 2 | 15% | 1.5% |
| 3 | 10% | 1.0% |
| 4-5 | 5-7% | 0.5-0.7% |
| 6-10 | 2-4% | 0.2-0.4% |
This means impressions are a stronger signal than clicks for niche sites. Wire's opportunity scoring accounts for this by weighting impressions, not clicks.
Why Local-First Beats API-On-Demand
Most SEO tools query Google's API on every interaction. Wire downloads the data once, stores it locally, and runs every analysis from the database. Three advantages compound from this architecture.
Speed. A SQL query takes milliseconds. An API call takes 2-5 seconds. When Wire runs find_overlaps() across 142 pages, it completes in under a second. An API-on-demand tool would make 142 separate requests, over 5 minutes of wall time, plus rate limit pauses.
Cost control. GSC's API has a daily quota. Tools that query on every user interaction burn through quota fast. Wire's quota usage is fixed: one fetch cycle per topic, regardless of how many analyses you run afterward. The data command hits the API once. Every subsequent command (audit, deduplicate, reword, enrich) reads from the local database at zero API cost.
Reproducibility. The local database is a snapshot. Two analyses run on the same snapshot produce identical results. This matters for debugging and for comparing changes across workflow cycles. When you run audit on Monday and audit on Friday, the data difference is explicit: one snapshot versus another, not random API variance.
The approach mirrors what large SEO teams do manually with spreadsheets: download the data, analyze locally, act on the analysis. Wire automates the analysis step.
The Impression-First Thesis
The traditional SEO playbook optimizes for clicks. Wire optimizes for impressions. The reasoning is structural, not contrarian.
Seer Interactive's analysis of AI Overview impact found that AI Overviews reduce organic CTR by 34-61% depending on query type. Ahrefs' December 2025 study measured a 58% CTR reduction at position one when an AI Overview is present. Position one with a 2.8% CTR means 97.2% of impressions never become clicks.
Click-based scoring in this environment is misleading. A keyword with 500 impressions and 5 clicks looks like a 1% CTR failure. But that keyword represents 500 people who searched for your topic. 495 of them saw an AI Overview that answered their question. The 5 who clicked through are the ones the AI Overview failed to satisfy, and they are disproportionately valuable because they wanted more than a summary.
Wire's opportunity formula, impressions * (1 - CTR), captures this. It scores 500 impressions at 1% CTR as 495. It scores 50 impressions at 10% CTR as 45. The first keyword has 11x more untapped demand. That is where content investment should go.
This thesis has a testable prediction: sites that optimize for impression-weighted keywords will outperform sites that optimize for click-weighted keywords over 6-12 months, because impression-weighted optimization targets the queries where AI Overviews intercept the most traffic, and those AI Overviews will change, fail, or lose user trust over time.
Authentication
Wire uses Google OAuth for GSC access. You need GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET in your .env file, plus a token.json generated on first authentication. See the getting started guide for setup instructions.