Python for SEO: Automate Your Way to Efficiency

`python import pandas as pd import requests from concurrent.futures import ThreadPoolExecutor

def check_url(url): try: response = requests.head(url, timeout=10, allow_redirects=True) return { 'url': url, 'status_code': response.status_code, 'final_url': response.url, 'redirect': url != response.url } except Exception as e: return {'url': url, 'status_code': 'Error', 'error': str(e)}

# Load URLs from file urls = pd.read_csv('urls.csv')['url'].tolist()

# Check URLs in parallel with ThreadPoolExecutor(max_workers=10) as executor: results = list(executor.map(check_url, urls))

# Save results df = pd.DataFrame(results) df.to_csv('url_status_report.csv', index=False) `

Script 2: Google Search Console Data Extractor

Pull performance data directly from Search Console API:

`python from google.oauth2 import service_account from googleapiclient.discovery import build import pandas as pd

# Authenticate credentials = service_account.Credentials.from_service_account_file( 'service-account.json', scopes=['https://www.googleapis.com/auth/webmasters.readonly'] )

service = build('searchconsole', 'v1', credentials=credentials)

# Define request request = { 'startDate': '2026-01-01', 'endDate': '2026-01-28', 'dimensions': ['query', 'page'], 'rowLimit': 5000 }

# Execute response = service.searchanalytics().query( siteUrl='https://yoursite.com', body=request ).execute()

# Convert to DataFrame df = pd.DataFrame(response['rows']) df.to_csv('gsc_data.csv', index=False) `

Script 3: Content Gap Analysis

Compare your content coverage against competitors:

`python import pandas as pd

# Load keyword data (exported from Ahrefs/Semrush) your_keywords = pd.read_csv('your_keywords.csv') competitor_keywords = pd.read_csv('competitor_keywords.csv')

# Find gaps your_set = set(your_keywords['keyword']) competitor_set = set(competitor_keywords['keyword'])

gaps = competitor_set - your_set

# Create report with metrics gap_df = competitor_keywords[competitor_keywords['keyword'].isin(gaps)] gap_df = gap_df.sort_values('search_volume', ascending=False) gap_df.to_csv('content_gaps.csv', index=False)

print(f"Found {len(gaps)} content gap opportunities") `

Script 4: Internal Link Analyzer

Map your internal link structure:

`python import requests from bs4 import BeautifulSoup from urllib.parse import urljoin, urlparse import pandas as pd

def get_internal_links(url, domain): try: response = requests.get(url, timeout=10) soup = BeautifulSoup(response.text, 'html.parser') links = [] for link in soup.find_all('a', href=True): href = urljoin(url, link['href']) if urlparse(href).netloc == domain: links.append({ 'source': url, 'target': href, 'anchor_text': link.get_text(strip=True) }) return links except: return []

# Crawl your site (simplified) domain = 'yoursite.com' start_url = 'https://yoursite.com' all_links = get_internal_links(start_url, domain)

df = pd.DataFrame(all_links) df.to_csv('internal_links.csv', index=False) `

Script 5: Automated SEO Report Generator

Generate weekly client reports automatically:

`python import pandas as pd from datetime import datetime

def generate_report(client_name, gsc_data, rankings_data): # Calculate metrics total_clicks = gsc_data['clicks'].sum() avg_position = gsc_data['position'].mean() top_10_keywords = len(rankings_data[rankings_data['position'] <= 10]) report = f""" SEO Performance Report - {client_name} Generated: {datetime.now().strftime('%Y-%m-%d')} Executive Summary: - Total Organic Clicks: {total_clicks:,} - Average Position: {avg_position:.1f} - Keywords in Top 10: {top_10_keywords} Top Performing Pages: {gsc_data.nlargest(5, 'clicks')[['page', 'clicks']].to_string()} Keywords to Focus On: {rankings_data[(rankings_data['position'] > 10) & (rankings_data['position'] <= 20)].head(10).to_string()} """ return report

# Generate and save report = generate_report('Client X', gsc_df, rankings_df) with open('weekly_report.txt', 'w') as f: f.write(report) `

Building Automated Workflows

Daily Rank Tracking Pipeline

`python import schedule import time

def daily_rank_check(): # 1. Pull current rankings rankings = get_rankings_from_api() # 2. Compare with previous day changes = compare_rankings(rankings) # 3. Alert on significant changes if any(abs(c) > 5 for c in changes['position_change']): send_slack_alert(changes) # 4. Store historical data save_to_database(rankings)

# Schedule daily at 9 AM schedule.every().day.at("09:00").do(daily_rank_check)

while True: schedule.run_pending() time.sleep(60) `

Content Audit Automation

`python def automated_content_audit(sitemap_url): # 1. Parse sitemap for all URLs urls = parse_sitemap(sitemap_url) # 2. Fetch each page's data page_data = [] for url in urls: data = { 'url': url, 'word_count': get_word_count(url), 'title_length': len(get_title(url)), 'meta_desc_length': len(get_meta_description(url)), 'h1_count': count_h1_tags(url), 'internal_links': count_internal_links(url), 'load_time': measure_load_time(url) } page_data.append(data) # 3. Identify issues df = pd.DataFrame(page_data) issues = { 'thin_content': df[df['word_count'] < 300], 'missing_meta': df[df['meta_desc_length'] == 0], 'slow_pages': df[df['load_time'] > 3] } return df, issues `

Tips for Success

Start Small

Don't try to automate everything at once: 1. Identify your most time-consuming task 2. Build a script to handle it 3. Test and refine 4. Move to the next task

Error Handling is Essential

Always account for failures:

`python try: result = risky_operation() except Exception as e: log_error(e) send_alert("Script failed") result = default_value `

Document Everything

Future you will thank present you:

`python def analyze_keywords(keyword_list, min_volume=100): """ Analyze a list of keywords for SEO potential. Args: keyword_list: List of keyword strings min_volume: Minimum search volume threshold Returns: DataFrame with analysis results """ # Your code here ``

Resources for Learning More

Free courses:

SEO-specific Python:

Conclusion

Automation isn't about replacing your expertise—it's about amplifying it. The hours you save on manual tasks can be reinvested in strategy, analysis, and creative problem-solving.

Start with one script. Solve one problem. Then build from there.

Your future self (and your clients) will thank you.