DEV Community: Carllowman

Boost Rich Results with Automated JSON-LD Schema for Blogs

Carllowman — Fri, 05 Jun 2026 05:45:48 +0000

Just built a quick script to generate JSON-LD schema for my blog posts automatically. No more manual copy-paste from Google's Structured Data Testing Tool.

The idea: parse the article's title, description, publish date, and author from frontmatter, then output a valid Article schema.

python
import frontmatter
import json

def generate_article_schema(post):
schema = {
"@context": "https://schema.org",
"@type": "Article",
"headline": post['title'],
"description": post.get('description', ''),
"datePublished": post['date'],
"author": {
"@type": "Person",
"name": post['author']
}
}
return json.dumps(schema, indent=2)

Example usage

post = frontmatter.load('my-post.md')
schema = generate_article_schema(post.metadata)
print(schema)

This handles basic articles, but for richer types like FAQ, Recipe, or Product, you need more fields. I've been using SERPSpur's Schema Markup Generator to handle those complex cases — it outputs clean JSON-LD that passes validation.

The biggest benefit? Google started showing my posts in rich results within a week. Traffic from featured snippets went up by about 15%.

What schema types have you found most impactful for SEO?

https://serpspur.com

How to Handle Location Spoofing for Accurate Local SEO Testing

Carllowman — Thu, 04 Jun 2026 04:28:12 +0000

If you've ever worked on local SEO campaigns, you've probably noticed that search results can vary dramatically depending on where the searcher is located.

A business may rank #1 in one neighborhood but disappear from the top results just a few miles away. This makes testing local search visibility challenging, especially when you're trying to optimize rankings across multiple locations.

Why Location Matters in Search Results

Google personalizes search results based on several factors, including:

User location
Search history
Device type
Language settings
Local intent signals

For example, searching for "best coffee shop" in New York will return completely different results than searching for the same term in Los Angeles.

This creates a challenge for SEO professionals who need accurate ranking data from locations they aren't physically present in.

Traditional Methods for Testing Local Rankings

In the past, many SEOs relied on:

VPN services
Browser location settings
Incognito mode
Local proxies

While these methods can help, they often introduce inconsistencies and don't always replicate actual local search experiences.

My Approach to Location Spoofing

When testing local search results, I focus on simulating searches from specific cities, regions, and languages while minimizing personalization factors.

*1. Define the Target Location
*
Examples:

Dallas, Texas
London, United Kingdom
Sydney, Australia
*2. Remove Personalization
*
Use:

Incognito mode
Logged-out browser sessions
Cleared cookies and cache
*3. Simulate Local Searches
*
Location spoofing tools can emulate searches from different cities, regions, and languages without requiring physical presence in those locations.

*This helps analyze:
*
Local Pack rankings
Organic rankings
Competitor visibility
Geographic ranking fluctuations
Example: Automating Local Search Checks with Python

The following example demonstrates how you might automate location-based SERP testing using a location-spoofing service or API.

import requests

keyword = "best coffee shop"
location = "New York, NY"

payload = {
"keyword": keyword,
"location": location,
"language": "en",
"country": "US"
}

response = requests.post(
"https://api.example.com/local-search",
json=payload
)

results = response.json()

print(f"Keyword: {keyword}")
print(f"Location: {location}")

for rank, result in enumerate(results["organic_results"], start=1):
print(f"{rank}. {result['title']}")
print(f" URL: {result['url']}")

This workflow allows you to compare search results from multiple locations without manually changing browser settings each time.

Example: Compare Rankings Across Multiple Cities
cities = [
"New York, NY",
"Chicago, IL",
"Los Angeles, CA",
"Houston, TX"
]

keyword = "plumber near me"

for city in cities:
payload = {
"keyword": keyword,
"location": city
}

response = requests.post(
    "https://api.example.com/local-search",
    json=payload
)

data = response.json()

print(f"\nResults for {city}")
print("-" * 40)

for rank, result in enumerate(data["organic_results"][:5], start=1):
    print(f"{rank}. {result['title']}")

This type of automation is especially useful for agencies managing local SEO campaigns across dozens of cities.

Benefits of Location Spoofing for SEO
Better Local SEO Audits

You can identify location-specific ranking issues that standard rank tracking often misses.

Competitor Analysis

Understand how competitors perform in different markets and uncover opportunities to gain visibility.

Google Business Profile Optimization

Location testing helps verify whether your business appears consistently in targeted areas.

More Accurate Reporting

Clients receive ranking data that reflects actual user experiences rather than generic national rankings.

Common Mistakes to Avoid
Relying Only on VPNs

VPNs change your IP address but don't always replicate Google's local search signals accurately.

Testing from a Single Location

Local SEO performance can vary significantly even within the same city.

Ignoring Language and Region Settings

Search results can differ based on language preferences and regional targeting.

Not Tracking Changes Over Time

Local rankings fluctuate frequently, so regular monitoring is essential.

Advanced Tip

When analyzing local SEO performance, compare:

City-level rankings
ZIP/postal code rankings
Language-specific results
Mobile vs desktop rankings

This provides a much more accurate picture of your actual visibility.

Final Thoughts

Location spoofing has become an essential part of modern local SEO. By simulating searches from different geographic areas, you can uncover ranking opportunities, identify visibility gaps, and make better optimization decisions.

Whether you're managing a single local business or multiple client campaigns, location-based SERP testing can provide valuable insights that standard rank tracking often misses.

How do you handle location spoofing for testing search results? Share your workflow and favorite tools in the comments!

Fix Duplicate Content Issues in SEO Using a Simple Python Similarity Checker Script

Carllowman — Wed, 03 Jun 2026 08:49:24 +0000

Struggling with duplicate content across multiple landing pages? I wrote a quick script to compare text similarity using cosine similarity with TF-IDF vectors. Here's how:

python
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

def check_duplicates(texts):
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform(texts)
similarity = cosine_similarity(tfidf_matrix)
for i in range(len(similarity)):
for j in range(i+1, len(similarity)):
if similarity[i][j] > 0.8:
print(f"High similarity between page {i} and {j}: {similarity[i][j]:.2f}")

This flagged several pages that needed rewriting. For larger audits, I've been using a tool that automates this analysis. How do you handle duplicate content detection?

Handle Duplicate Content : https://serpspur.com

How I Checked London Google Rankings While Working Remotely from Tokyo

Carllowman — Tue, 02 Jun 2026 10:40:58 +0000

I needed to check how my website ranks for 'plumber London' from a user actually in London. But I'm sitting in a café in Tokyo. Remote work problems, right?

My quick fix was a bash script that uses curl with custom headers and a geolocation-aware proxy:

bash

!/bin/bash

QUERY="plumber London"
COUNTRY="GB"
LANGUAGE="en"
PROXY="london-proxy.example.com:8080"

curl -s -H "Accept-Language: $LANGUAGE" \
--proxy "http://$PROXY" \
"https://www.google.com/search?q=$QUERY&gl=$COUNTRY" | \
grep -oP '
]>.?
' | \
sed 's/]*>//g'

This gives me the top results' titles. But maintaining a list of reliable proxies for every city I need to test is a full-time job. I've since moved to a service that provides clean, location-specific search data without the proxy headache.

**[I needed to check how my website ranks for 'plumber London' from a user actually in London. But I'm sitting in a café in Tokyo. Remote work problems, right?

My quick fix was a bash script that uses curl with custom headers and a geolocation-aware proxy:

bash

!/bin/bash

QUERY="plumber London"
COUNTRY="GB"
LANGUAGE="en"
PROXY="london-proxy.example.com:8080"

curl -s -H "Accept-Language: $LANGUAGE" \
--proxy "http://$PROXY" \
"https://www.google.com/search?q=$QUERY&gl=$COUNTRY" | \
grep -oP '
]>.?
' | \
sed 's/]*>//g'

https://serpspur.com