Advanced Technical SEO Strategies
Crawl Log Analysis
Beyond Simulators: Real Crawl Log Analysis
Simulated crawlers like Screaming Frog provide a valuable snapshot of your site's architecture, but they only show you what's possible. They don't reveal what search engine bots actually do. To get that ground truth, you need to analyse your raw server logs. This is where you can see every single request made by Googlebot and Bingbot, revealing their priorities and frustrations.
The core task of log file analysis is to identify the 'crawl gap'. This is the difference between Google's theoretical crawl capacity for your site and the crawl demand it actually expresses. Capacity is the total number of URLs Googlebot could fetch in a given period. Demand is what it chooses to fetch based on its perception of your content's value and authority. Closing this gap means forcing Google to spend its limited time on your most important pages.
Isolating Search Engine Bots
Your server logs capture every hit, from real users to benign scrapers and malicious bots. The first step is to filter this noise to isolate legitimate search engine crawlers. You can start by filtering for requests where the user-agent string matches known bot identifiers.
# Example User-Agent Strings
# Googlebot (Smartphone)
Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)
# Bingbot
Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)
Filtering by user-agent alone is unreliable. Malicious bots often spoof these strings to bypass simple blocks. The definitive method for verification is a . By performing a reverse lookup on the IP address from the log entry, you can confirm it resolves to a genuine Google or Microsoft domain (like .googlebot.com or .search.msn.com). A subsequent forward DNS lookup on that domain should then point back to the original IP address. This two-step process weeds out impersonators, leaving you with a clean dataset of actual search engine bot activity.
Diagnosing Crawl Waste
With a clean log file of bot traffic, you can begin to quantify crawl waste. This is any activity where bots spend time on URLs that provide no value or lead to dead ends. Every wasted request is a missed opportunity to crawl and index a page that matters.
Common sources of waste are redirect chains (301/302 status codes) and error pages (4xx status codes). While a single 301 redirect is standard practice, logs can reveal bots repeatedly hitting old URLs that should have been updated long ago, or getting stuck in redirect loops. Consistently high numbers of 404s indicate bots are following broken internal or external links, chewing through your without discovering any content.
Perhaps the most significant source of waste for large e-commerce or publisher sites is parameter-driven URL bloat. This occurs when faceted navigation or tracking parameters generate thousands of near-duplicate URL variations. If not handled correctly via rel="canonical" or robots.txt disallows, bots can waste the majority of their time crawling endless combinations of filtered pages that you have no intention of ranking.
Optimising Demand with BigQuery
The ultimate goal is to align Google's crawl demand with your business priorities. This requires joining your log data with your own business intelligence. By uploading your log files to a platform like Google BigQuery, you can run powerful SQL queries against millions of lines of data in seconds.
Imagine you have a list of high-value 'money pages' (e.g., top-converting products, core service pages) in one table and your Googlebot crawl data in another. You can join these datasets to pinpoint which of your most important URLs are being under-crawled. Conversely, you can identify which low-value URLs (like faceted search results) are being over-crawled and wasting resources.
-- Find money pages with low crawl frequency
WITH MoneyPages AS (
SELECT url
FROM `my_project.seo_data.priority_urls`
WHERE page_type = 'Product'
),
GooglebotLogs AS (
SELECT
req_url AS url,
COUNT(req_url) AS crawl_count
FROM `my_project.server_logs.access_logs`
WHERE user_agent LIKE '%Googlebot%'
AND status_code = 200
AND date BETWEEN '2023-10-01' AND '2023-10-31'
GROUP BY url
)
SELECT
mp.url,
COALESCE(gl.crawl_count, 0) AS monthly_crawls
FROM MoneyPages mp
LEFT JOIN GooglebotLogs gl ON mp.url = gl.url
WHERE COALESCE(gl.crawl_count, 0) < 5 -- Find pages crawled less than 5 times a month
ORDER BY monthly_crawls ASC;
This query provides an actionable list of high-priority pages that Google is neglecting. The inverse analysis is just as important: finding low-value URLs with high crawl counts points directly to where you should implement robots.txt disallows or add nofollow attributes to internal links.
Another powerful technique is log-to-sitemap gap analysis. By comparing the URLs Googlebot is hitting against the URLs listed in your XML sitemaps, you can discover 'orphaned pages'. These are pages that are being crawled (often via legacy links) but are not part of your intended site structure. Finding and either redirecting or deleting these pages is critical for efficient site maintenance.
Improving crawl efficiency doesn’t mean “getting more crawled.” It means helping search engines waste less time on garbage so they can focus on what matters.
Ultimately, log file analysis provides the factual foundation for strategic technical SEO. The insights you gain allow you to move beyond best-practice guesses and make data-driven decisions that directly influence how search engines perceive and prioritise your website.