Python Scripts Every Digital Marketer Should Use in 2026

# serp_spotcheck.py
import requests
from bs4 import BeautifulSoup
import pandas as pd
import time, random

def fetch_google_results(query, num=10):
url = “https://www.google.com/search”
headers = {“User-Agent”: “Mozilla/5.0 (compatible)”}
params = {“q”: query, “num”: num}
r = requests.get(url, params=params, headers=headers, timeout=10)
r.raise_for_status()
return r.text

def parse_results(html):
soup = BeautifulSoup(html, “html.parser”)
results = []
for g in soup.select(“.tF2Cxc”):
title = g.select_one(“h3”)
link = g.select_one(“a”)
snippet = g.select_one(“.VwiC3b”)
results.append({
“title”: title.get_text(strip=True) if title else “”,
“link”: link[‘href’] if link else “”,
“snippet”: snippet.get_text(strip=True) if snippet else “”
})
return results

if __name__ == “__main__”:
keywords = [“python for seo automation”, “seo trends 2026”]
rows = []
for kw in keywords:
html = fetch_google_results(kw, num=10)
rows.extend([{“keyword”: kw, **r} for r in parse_results(html)])
time.sleep(random.uniform(2,4))
df = pd.DataFrame(rows)
df.to_csv(“serp_spotcheck.csv”, index=False)
print(“Saved serp_spotcheck.csv”)

# seo_audit_basic.py
import requests
from bs4 import BeautifulSoup
import pandas as pd
from urllib.parse import urljoin

def fetch_meta(url):
r = requests.get(url, timeout=10)
r.raise_for_status()
soup = BeautifulSoup(r.text, “html.parser”)
title = soup.title.string.strip() if soup.title else “”
desc = soup.find(“meta”, attrs={“name”:“description”})
desc = desc[“content”].strip() if desc else “”
h1 = soup.find(“h1”)
h1 = h1.get_text(strip=True) if h1 else “”
images = [img.get(“src”) for img in soup.find_all(“img”) if img.get(“src”)]
images = [urljoin(url, src) for src in images]
return {“url”: url, “title”: title, “meta_description”: desc, “h1”: h1, “image_count”: len(images)}

if __name__ == “__main__”:
urls = [“https://softbrimmedia.com/”,“https://softbrimmedia.com/seo-in-2026-how-ai-voice-search-user-experience-are-changing-rankings/”]
rows = [fetch_meta(u) for u in urls]
pd.DataFrame(rows).to_csv(“seo_audit_basic.csv”, index=False)
print(“Saved seo_audit_basic.csv”)

# keyword_clustering.py
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans

def cluster_keywords(keywords, n_clusters=5):
vec = TfidfVectorizer(ngram_range=(1,2), stop_words=‘english’)
X = vec.fit_transform(keywords)
kmeans = KMeans(n_clusters=n_clusters, random_state=42).fit(X)
return pd.DataFrame({“keyword”: keywords, “cluster”: kmeans.labels_})

if __name__ == “__main__”:
kws = [“seo trends 2026”, “future of seo”, “ai seo”, “voice search optimization”, “video seo tips”, “on-page seo checklist”]
print(cluster_keywords(kws, n_clusters=3))

# content_brief.py (pseudocode)
def generate_brief(topic):
prompt = f"Create a detailed blog outline for: {topic}. Include H1,H2,H3, 500-word summary and 5 FAQs."
resp = llm_generate(prompt) # replace with your provider call
return resp

if __name__ == “__main__”:
print(generate_brief(“Python scripts every digital marketer should use in 2026”))

# backlink_monitor.py
import requests
from bs4 import BeautifulSoup
import pandas as pd

def check_backlink(url):
try:
r = requests.get(url, timeout=10, allow_redirects=True)
soup = BeautifulSoup(r.text, “html.parser”)
return {“url”: url, “status”: r.status_code, “final_url”: r.url, “title”: soup.title.string.strip() if soup.title else “”}
except Exception as e:
return {“url”: url, “status”: “error”, “error”: str(e)}

if __name__ == “__main__”:
backlinks = [“https://example.com/linking-page”]
df = pd.DataFrame([check_backlink(u) for u in backlinks])
df.to_csv(“backlinks_status.csv”, index=False)

# gsc_pull.py (conceptual)
from googleapiclient.discovery import build
from google.oauth2.service_account import Credentials
import pandas as pd

SCOPES = [‘https://www.googleapis.com/auth/webmasters.readonly’]
KEY_FILE = ‘service_account.json’
SITE = ‘https://softbrimmedia.com/’

creds = Credentials.from_service_account_file(KEY_FILE, scopes=SCOPES)
service = build(‘webmasters’, ‘v3’, credentials=creds)

request = {
“startDate”: “2025-11-01”,
“endDate”: “2025-12-01”,
“dimensions”: [“query”,“page”],
“rowLimit”: 2500
}
response = service.searchanalytics().query(siteUrl=SITE, body=request).execute()
rows = response.get(“rows”, [])
# transform to dataframe…

# caption_tester.py (logic)
import pandas as pd

variants = [
{“text”: “SEO in 2026: AI is reshaping search – read more”, “variant”:“A”},
{“text”: “Future of SEO: voice, AI, and UX – a full guide”, “variant”:“B”},
]

# After running a live campaign, collect metrics manually or via API
results = [
{“variant”:“A”,“impressions”:1200,“clicks”:48,“likes”:30},
{“variant”:“B”,“impressions”:1300,“clicks”:70,“likes”:55},
]
df = pd.DataFrame(results)
df[‘ctr’] = df[‘clicks’]/df[‘impressions’]
print(df.sort_values(‘ctr’, ascending=False))

# alt_text_generator.py (simple approach)
from PIL import Image
import pytesseract # for OCR; install tesseract separately
import tldextract
import os

def simple_alt_from_filename(path):
return os.path.splitext(os.path.basename(path))[0].replace(‘-‘, ‘ ‘)

if __name__ == “__main__”:
print(simple_alt_from_filename(“seo-trends-2026-laptop.png”))

# rank_chart.py
import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv(“rank_history.csv”) # columns: date, keyword, rank
keyword = “seo trends 2026”
kdf = df[df[‘keyword’]==keyword].sort_values(‘date’)
plt.plot(kdf[‘date’], kdf[‘rank’])
plt.gca().invert_yaxis()
plt.title(keyword)
plt.xlabel(‘Date’)
plt.ylabel(‘Rank’)
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# outreach_template.py (skeleton)
import smtplib
from email.message import EmailMessage

def send_email(to, subject, html_body, smtp_config):
msg = EmailMessage()
msg[‘Subject’] = subject
msg[‘From’] = smtp_config[‘from’]
msg[‘To’] = to
msg.set_content(html_body, subtype=‘html’)
with smtplib.SMTP_SSL(smtp_config[‘host’], smtp_config[‘port’]) as s:
s.login(smtp_config[‘user’], smtp_config[‘pass’])
s.send_message(msg)

# report_builder.py (pattern)
import pandas as pd

df1 = pd.read_csv(“gsc_data.csv”)
df2 = pd.read_csv(“analytics.csv”)
with pd.ExcelWriter(“monthly_report.xlsx”) as writer:
df1.to_excel(writer, sheet_name=“GSC”, index=False)
df2.to_excel(writer, sheet_name=“Analytics”, index=False)
print(“Report built: monthly_report.xlsx”)

# parse_logs.py (simple)
import pandas as pd
def parse_nginx_log_line(line):
# adapt to your log format; this is illustrative
parts = line.split()
return {"ip": parts[0], "datetime": parts[3].lstrip('['), "method": parts[5].strip('"'), "path": parts[6], "status": parts[8]}

with open(“access.log”) as f:
rows = [parse_nginx_log_line(l) for l in f if l.strip()]
df = pd.DataFrame(rows)
df[‘status’] = df[‘status’].astype(int)
df[df[‘status’]==404].to_csv(“404s.csv”, index=False)