DEV Community: Lucy Green

Simplify Keyword Research with Search Volume, CPC & Difficulty

Lucy Green — Tue, 07 Jul 2026 09:34:28 +0000

Keyword research is the backbone of any SEO strategy. But with so many metrics—search volume, CPC, keyword difficulty, ads competition—it can get overwhelming. The Keyword Research Tool simplifies this by providing all these metrics in one place, filtered by country. For example, you can quickly compare 'best coffee maker' across the US and UK to see where the opportunity lies. Here's a quick Python script to fetch keyword data programmatically:

python
import requests

url = 'https://serpspur.com/tool/keyword-research-tool/'
params = {'keyword': 'best coffee maker', 'country': 'US'}
response = requests.get(url, params=params)
data = response.json()
print(f'Search Volume: {data["search_volume"]}, Difficulty: {data["difficulty"]}')

Check it out at https://serpspur.com/tool/keyword-research-tool/ to refine your keyword strategy.

How I Use Competitor Traffic Analysis to Discover New SEO Opportunities

Lucy Green — Mon, 06 Jul 2026 06:47:08 +0000

If you're serious about SEO, you need to know what your competitors are doing. The SERPSpur Traffic & Competitor Explorer makes it easy to analyze website traffic, organic keywords, and competitor performance across different search markets. I wrote a small PHP script to automate competitor analysis:

This helps me identify which keywords I'm missing and where to focus my efforts. Head over to https://serpspur.com to start exploring.

How I Verify Website Traffic Before Buying a Domain or Building Backlinks

Lucy Green — Fri, 03 Jul 2026 05:59:31 +0000

Before buying a domain on Flippa or investing in link building, I always check traffic authenticity. Fake bot traffic can ruin your ROI. I built a simple Python script to analyze user-agent patterns, but it's not enough. That's why I use the SERPSpur Bot Traffic Detector—it identifies fake bot and low-quality traffic sources, giving you confidence in your investment.

python
import re

def detect_bot_traffic(log_entry):
bot_patterns = [r'bot', r'crawler', r'spider', r'scraper']
user_agent = log_entry.get('user_agent', '')
for pattern in bot_patterns:
if re.search(pattern, user_agent, re.IGNORECASE):
return True
return False

Example log entry

log = {'user_agent': 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)'}
print('Bot detected' if detect_bot_traffic(log) else 'Human traffic')

This snippet is a starting point, but the tool does a triple-signal audit for accuracy. Check it out: https://serpspur.com/tool/bot-traffic-detector/

Automating SEO Audits with Python (and Taking Them Further)

Lucy Green — Sat, 27 Jun 2026 04:37:56 +0000

If you've ever managed more than a handful of websites, you've probably spent far too much time checking the same things over and over again:

Is the title tag missing?
Does every page have a meta description?
Are images missing alt attributes?
Is there exactly one <h1>?
Are canonical tags configured correctly?

Doing this manually gets old fast.

I wanted a lightweight way to catch the obvious issues before running a full SEO audit, so I put together a simple Python script that scans a page and reports common on-page problems.

Install the Dependencies

pip install requests beautifulsoup4

Basic SEO Audit Script

import requests
from bs4 import BeautifulSoup

def audit_page(url):
    response = requests.get(url, timeout=10)
    soup = BeautifulSoup(response.text, "html.parser")

    issues = []

    title = soup.title.string.strip() if soup.title and soup.title.string else ""
    if not title:
        issues.append("Missing title tag")
    elif len(title) > 60:
        issues.append("Title exceeds recommended length")

    description = soup.find("meta", attrs={"name": "description"})
    if not description or not description.get("content"):
        issues.append("Missing meta description")

    h1_tags = soup.find_all("h1")
    if len(h1_tags) == 0:
        issues.append("Missing H1")
    elif len(h1_tags) > 1:
        issues.append("Multiple H1 tags detected")

    images = soup.find_all("img")
    missing_alt = [img.get("src") for img in images if not img.get("alt")]

    if missing_alt:
        issues.append(f"{len(missing_alt)} images missing alt text")

    canonical = soup.find("link", rel="canonical")
    if not canonical:
        issues.append("Missing canonical tag")

    return issues

url = "https://example.com"

for issue in audit_page(url):
    print("-", issue)

For quick technical checks, this script works surprisingly well.

But after using it for client projects, I realized something important:

An on-page audit is only one piece of the puzzle.

SEO Doesn't Stop at HTML

Even when every page has perfect metadata, rankings can still suffer because of:

Weak backlink profiles
Poor keyword targeting
Slow Core Web Vitals
Indexing issues
Broken internal links
Missing structured data
Competitor content gaps

Checking all of those manually quickly becomes overwhelming.

Extending the Workflow

Instead of writing separate scripts for every SEO task, I now use this script as the first validation step and then follow it with a more comprehensive audit using SERPSpur.

It gives me additional insights such as:

On-page SEO analysis
Backlink reports
Keyword research
Competitor comparisons
Domain authority metrics
Rank tracking
Technical SEO diagnostics

That means I can identify both HTML-level issues and broader SEO problems from a single workflow.

Ideas for Improvements

If you're extending this script, here are a few useful additions:

Validate Open Graph tags
Check Twitter Card metadata
Detect broken internal links
Verify structured data (JSON-LD)
Audit robots meta directives
Measure page response time
Detect duplicate meta descriptions
Export results as CSV
Crawl an entire sitemap
Generate HTML reports

Final Thoughts

Automation won't replace a proper SEO strategy, but it can eliminate a lot of repetitive work.

A simple Python script is perfect for catching common on-page issues before they become bigger problems. Pairing it with a comprehensive SEO platform lets you move beyond HTML validation and understand how your site performs in search.

Whether you're maintaining your own projects or auditing client websites, combining lightweight automation with a full SEO toolkit can save hours every week.

If you're looking for an all-in-one SEO platform to complement your own scripts, take a look at SERPSpur: https://serpspur.com

Backlink Gap Analysis: The Smartest Way to Find High-Quality Link Opportunities

Lucy Green — Wed, 24 Jun 2026 05:47:35 +0000

Backlink gaps are one of the easiest ways to find new link-building opportunities. The concept is simple: find sites that link to your competitors but not to you. Those are potential targets for outreach.

I've used this method for years. It's more efficient than cold pitching random sites because you know these sites already link to similar content.

Here's a basic Python script to find backlink gaps using a hypothetical API:

python
import requests

def find_backlink_gaps(your_domain, competitor_domain):
# Pseudocode—replace with actual API calls
your_backlinks = get_backlinks(your_domain)
competitor_backlinks = get_backlinks(competitor_domain)

gaps = set(competitor_backlinks) - set(your_backlinks)
return gaps

gaps = find_backlink_gaps("yoursite.com", "competitor.com")
print(f"Found {len(gaps)} backlink opportunities")

But scraping backlink data from scratch is complex. You need a reliable index. That's where a tool like SERPSpur's Backlink Gap Analysis Tool comes in. It compares your domain against competitors and lists all the sites linking to them but not to you.

Once you have that list, outreach becomes targeted. You know these sites are relevant and already link to similar content. Just craft a personalized pitch showing why your resource adds value.

This approach consistently yields high-quality backlinks because the linkers are pre-qualified.

PageRank May Be Dead, But Its Ghost Still Haunts SEO

Lucy Green — Tue, 23 Jun 2026 13:52:12 +0000

Ever tried explaining PageRank to a new SEO? They think it's a dinosaur. Dead. Buried. But here's the thing—legacy data still tells a story. I was auditing an old client site recently, and the historical PageRank score was a ghost in the machine. It wasn't active, but the trust signals from back then were still echoing in their current backlink profile.

Here's a quick Python snippet to scrape the Wayback Machine for old PageRank data (if you have an API key for the deprecated Google Toolbar API, or you're using a fallback like Open PageRank):

import requests
from bs4 import BeautifulSoup

def check_legacy_pagerank(domain):
    # This is a simplified example using Open PageRank (free tier)
    url = f"https://openpagerank.com/api/v1.0/getPageRank?domains[]={domain}"
    headers = {"API-OPR": "your_api_key_here"}
    response = requests.get(url, headers=headers)
    data = response.json()
    return data['response'][0]['page_rank_decimal']

domain = "example.com"
legacy_rank = check_legacy_pagerank(domain)
print(f"Legacy PageRank for {domain}: {legacy_rank}")

But here's the catch—raw PageRank is just a number. It doesn't tell you if the trust is real or if it's from a link farm in 2008. That's where a modern trust metric comes in. I started cross-referencing these legacy scores with a real-time trust rate. For example, on SERPSpur, you can check the Trust Rate against historical PageRank. It's like having a time machine and a truth serum.

The math is simple: if a domain had a high PageRank in 2013 but a low Trust Rate now, it's probably been penalized or sold. If both are high, you've got a gem. I use this to filter out expired domains for side projects. No more wasting time on "authority" that's just a ghost.

Try it yourself. Grab your legacy PageRank data, then run it through a live trust checker. The difference is often shocking. And remember—data without context is just noise.

Security Doesn't Have to Be Ugly: Why I Chose Vintage-Style Rim Locks for My Front Door

Lucy Green — Fri, 12 Jun 2026 09:37:03 +0000

When renovating an older property, one of the biggest challenges is finding hardware that provides modern security without compromising the character of the home. Many contemporary locks prioritize function over appearance, often looking out of place on traditional doors. Fortunately, I recently discovered a solution that delivers both style and security: vintage-style rim locks.

After searching through countless options, I came across the rim lock collection from Infinity Decor. The combination of classic design, solid construction, and practical installation made them an easy choice for our front door renovation.

Why Rim Locks Are Ideal for Older Properties

Many period homes feature original wooden doors that were never designed to accommodate modern mortice locks. Installing a mortice lock often requires cutting deep into the door, which can weaken the structure and potentially damage historic woodwork.

Rim locks offer a practical alternative. Because they are surface-mounted, they require far less modification to the door itself. This makes them particularly suitable for:

Victorian properties
Georgian homes
Edwardian houses
Cottage renovations
Heritage restoration projects

For homeowners looking to preserve original features while improving security, rim locks provide an excellent balance between practicality and authenticity.

The Appeal of Vintage Brass Finishes

One of the first things that caught my attention was the beautiful brass finish. Hardware may seem like a small detail, but it can significantly influence the overall appearance of a property.

The warm brass tones complement traditional wood doors perfectly, creating a timeless look that feels authentic rather than decorative. Instead of standing out as a modern addition, the lock feels like it belongs to the property.

The result is a front entrance that looks elegant, welcoming, and historically appropriate.

Security You Can Rely On

While aesthetics were important, security remained the top priority.

The rim lock I selected includes a robust deadlock mechanism that provides confidence and peace of mind. It offers the reassuring feel of quality engineering while maintaining the traditional appearance that many homeowners seek.

Unlike some decorative hardware that focuses solely on looks, these locks are designed to perform as well as they look.

Straightforward Installation

Another pleasant surprise was how simple the installation process turned out to be.

The included hardware and clear fitting points meant the lock could be installed without extensive carpentry work. Since rim locks are mounted onto the surface of the door, the process is often less invasive than fitting a mortice lock.

For DIY enthusiasts, this can make the project far more approachable while reducing the risk of damaging an older door.

Creating a Cohesive Look

One tip I would strongly recommend is pairing the lock with matching door furniture.

Coordinating the rim lock with brass handles, escutcheons, and other hardware creates a unified appearance that elevates the entire entrance. Small details like these can transform a simple door into a standout architectural feature.

Consistency in finishes and styling helps maintain the character of a period property while giving it a polished, professional appearance.

Final Thoughts

Home security doesn't have to come at the expense of style. For anyone renovating an older property, vintage-style rim locks offer an attractive solution that combines classic aesthetics with dependable functionality.

The brass finish adds charm and authenticity, the deadlock mechanism provides reliable protection, and the straightforward installation makes them suitable for both professionals and confident DIY homeowners.

Anyone Else Seeing Big Ranking Differences Between Mobile and Desktop?

Lucy Green — Fri, 12 Jun 2026 07:47:44 +0000

Tracking keyword rankings across different devices and locations is crucial for understanding your SEO performance. I built this small script using the SerpSpur Live Search Engine Ranking Checker API to compare rankings by device type:

python
import requests

API_KEY = "your_api_key_here"

def compare_rankings_by_device(keyword, location):
results = {}
for device in ["desktop", "mobile", "tablet"]:
response = requests.get(
"https://api.serpspur.com/v1/live-ranking-checker",
headers={"Authorization": f"Bearer {API_KEY}"},
params={"q": keyword, "location": location, "device": device, "num": 10}
)
data = response.json()
results[device] = [r["position"] for r in data.get("organic_results", [])]
return results

Example usage

keyword = "SEO tools"
location = "United States"
rankings = compare_rankings_by_device(keyword, location)
for device, positions in rankings.items():
print(f"{device.upper()}: {positions[:5]}...")

This revealed some surprising differences—mobile rankings often vary significantly from desktop. Have you noticed similar patterns in your own tracking?

Automating Page Speed Audits: Python Script for Core Web Vitals Monitoring

Lucy Green — Thu, 04 Jun 2026 07:01:45 +0000

Just automated my weekly page speed audit with a Python script that pulls Core Web Vitals data and flags regressions before they hit production. No more surprise Lighthouse drops on Monday mornings.

Here's the core loop:

python
import requests
import json
from datetime import datetime

for url in urls:
response = requests.get
data = response.json()
if data['lcp'] > 2500 or data['cls'] > 0.1:
print(f"ALERT: {url} has poor vitals - LCP: {data['lcp']}ms, CLS: {data['cls']}")

It checks LCP, FID, and CLS against Google's thresholds. If any metric exceeds the limit, it logs the URL with a timestamp. I've got it running as a cron job every 6 hours.

The biggest win? Catching a third-party widget that bloated my TBT from 50ms to 350ms after an update. Rolled back within the hour.

This approach works with any API that exposes raw Web Vitals data. I'm using SERPSpur's Speed Forensics endpoint because it also gives me field data from Chrome UX Report, not just lab metrics.

Anyone else automating performance monitoring? What thresholds do you set for alerts?

Testing Geo-Targeted Google Search Results Without a VPN Using Puppeteer

Lucy Green — Mon, 01 Jun 2026 07:10:29 +0000

Just discovered a clever way to bypass Google's location redirect when testing local search results. Instead of relying on VPNs, I modify the navigator.geolocation API in a headless browser. Here's a Puppeteer snippet:

javascript
const puppeteer = require('puppeteer');

async function run() {
const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.goto;
await page.evaluate(() => {
navigator.geolocation.getCurrentPosition = (success) => {
success({ coords: { latitude: 40.7128, longitude: -74.0060 } });
};
});
// Now search for 'coffee shops' and see local results for NYC
}
run();

For production testing, I've been using SERPSpur's API which handles location spoofing natively. What's your most creative method for testing geo-targeted search results?