DEV Community: NAD14

How To Use Python For SEO Redirect Mapping

NAD14 — Sat, 16 May 2026 12:39:38 +0000

Website migrations often lead to broken links and ranking losses if redirects are not mapped correctly. Python makes this process faster and more accurate by automating URL matching using page titles, headings and fuzzy matching.

Instead of manually mapping hundreds or thousands of URLs, you can use Python to compare old and new site crawl data and generate redirect recommendations in minutes. This is especially useful during SEO website migrations, where preserving rankings, traffic and user experience is critical.

Why Use Python for Redirect Mapping?
Manual redirect mapping becomes difficult at scale and increases the risk of:

Missed URLs
Incorrect redirects
Redirect chains
Lost SEO equity
404 errors after launch
Python helps automate the process by:

Comparing old and new URLs
Matching pages using titles and headings
Scoring similarity between pages
Exporting redirect recommendations for review
For larger projects, this sits naturally alongside broader technical SEO work, including crawl optimisation, indexation checks and post-launch monitoring.

What You’ll Need
The latest version of Python
VS Code (or alternative code editor)
Screaming Frog (or alternative website crawler)
How To Install Python
Download the latest version of Python from:

Python.org

During installation:

Tick “Add Python to PATH”
Click Install Now
Once installed, restart your terminal or command prompt.

Check that Python is installed correctly
Open Terminal (Mac) or Command Prompt (Windows) and run:

Bash
python --version
You should see something similar to:

Terminal
Python 3.12.3
If that does not work on Windows, try:

Bash
py --version
Create a Project Folder
Create a new folder somewhere easy to access, for example:

File
seo-redirect-mapping
This will be the folder you will place your Screaming Frog crawls in.

Open the Folder in VS Code
Download:

Visual Studio Code

Then:

Open VS Code
Click File → Open Folder
Select your project folder
Create a new Python file called:

File
redirect-mapping.py
You are now ready to install the required libraries and run the script.

Gather Website Crawls
Before starting, gather crawl exports from both the old and new websites using a crawler such as Screaming Frog.

Download:

Screaming Frog

Your exports should include:

URL
Page title
H1
H2
Save both crawl exports as .xlsx files.

Preliminary Steps
Before running the steps below, open the integrated terminal in VS Code by clicking Terminal → New Terminal from the top menu.

This opens a terminal window directly inside your project folder. The pip install command in Step 1 is entered here.

For Steps 2 to 8, paste all of the code blocks into your redirect-mapping.py file in order, then run the script from the terminal using python redirect-mapping.py.

Before installing any libraries, it is recommended to set up a virtual environment. This keeps your project dependencies isolated and avoids conflicts with other Python projects on your machine.

Virtual environment — Mac
Bash
python -m venv venv
source venv/bin/activate
Virtual environment — Windows
Bash
python -m venv venv
venv\Scripts\activate
Once activated, you will see the environment name appear in your terminal. All libraries installed with pip will now be contained within this project folder. To deactivate the environment when you are finished, simply run deactivate as below:

Terminal
deactivate
Make sure the virtual environment is active in your terminal before moving on to Step 1. You will see (venv) at the start of your terminal prompt when it is activated. It should look a little something like this:

Terminal
(venv) your-machine-name:seo-redirect-mapping yourname$
Step-by-Step Guide

Install Required Libraries
Bash
pip install pandas polyfuzz rapidfuzz openpyxl
rapidfuzz is required separately for the matching model import to work correctly.
Import Libraries
Python
import pandas as pd
from polyfuzz import PolyFuzz
from polyfuzz.models import RapidFuzz
Load Crawl Data
Python
old_urls = pd.read_excel("old_site_crawl.xlsx")
new_urls = pd.read_excel("new_site_crawl.xlsx")

old_urls = old_urls.rename(columns={'Address': 'Old URL', 'Title 1': 'Old Title'})
new_urls = new_urls.rename(columns={'Address': 'New URL', 'Title 1': 'New Title'})
This assumes your Screaming Frog crawl exports use the default column names Address and Title 1, which are renamed in the code for clarity:

Title 1 → renamed to Old Title / New Title
Address → renamed to Old URL / New URL

Prepare Title Data Python old_titles_df = old_urls[['Old URL', 'Old Title']].dropna() new_titles_df = new_urls[['New URL', 'New Title']].dropna()

old_titles = old_titles_df['Old Title'].tolist()
new_titles = new_titles_df['New Title'].tolist()

Run Fuzzy Matching Python matcher = PolyFuzz(RapidFuzz()) matcher.match(old_titles, new_titles)

results = matcher.get_matches()["RapidFuzz"]
The output includes:

Original title
Suggested matching title
Similarity score

Filter High-Confidence Matches
Python
filtered_results = results[results["Similarity"] >= 0.90]
You can lower this threshold for larger or messier migrations, but anything below 0.80 should usually be reviewed manually.
Map Matches Back to URLs
Python
redirect_map = filtered_results.merge(
old_urls[['Old URL', 'Old Title']],
left_on='From',
right_on='Old Title'
)

redirect_map = redirect_map.merge(
new_urls[['New URL', 'New Title']],
left_on='To',
right_on='New Title'
)

final_redirects = redirect_map[
['Old URL', 'New URL', 'Similarity']
].copy()

final_redirects.columns = [
'Old URL',
'New URL',
'Confidence Score'
]

Export the Redirect Map Python final_redirects.to_excel( "redirect_mapping.xlsx", index=False ) You will now have an Excel file containing:

Old URL
Suggested new URL
Match confidence score
Review lower-confidence matches manually before implementation.

Tips for Better Redirect Matching
To improve accuracy:

Match using H1s if titles are inconsistent
Remove duplicate titles before matching
Exclude paginated or parameter URLs
Manually override important pages
Review all low-confidence matches
For important migrations, it is also worth carrying out an SEO audit before launch so technical issues, content gaps and redirect risks are identified early.

Final Thoughts
Python dramatically simplifies redirect mapping during SEO migrations. By automating title and content matching, you can generate scalable redirect recommendations quickly while reducing manual errors.

The workflow above gives you a reliable foundation that works well for most migrations and can easily be expanded for larger, more complex websites.

A Guide To Javascript SEO

NAD14 — Wed, 17 Jun 2020 22:25:41 +0000

As digital service professionals, we’ve all gotten well and truly used to our whole world changing in the blink of an eye.

Whether it’s adapting your website’s SEO in light of a new Google Algorithm update, or having to learn a new programming language every year!

But the truth is, that’s why we’re all in this profession. Because we absolutely hate it when things are easy and run smoothly… right?! Well, most of the time we like a challenge don’t we.

If you’re a web dev, SEO can often be challenging. Likewise, if you’re an SEO professional, development and programming can often seem overwhelming. But don’t worry, implementing javascript SEO isn’t about having to learn a completely new skill.

It’s become pretty common practice for websites to use javascript on websites to improve user experience and add certain levels of interactivity. Some websites use js for pulling product data, content, menus etc. - the list goes on.

As Google’s John Mueller states:

"The web has moved from plain HTML - as an SEO you can embrace that. Learn from JS devs & share SEO knowledge with them. JS's not going away."

So virtually every modern web developer will use javascript at some stage in a project.

So, what’s javascript SEO all about then?

What Is Javascript SEO?

The process of SEO for javascript is a division of technical SEO, and it’s about ensuring that websites which are javascript-heavy can easily be crawled and indexed by search engines. In most cases, this is about load times and the overarching effect on SEO.

Does this mean that javascript is bad for SEO? Absolutely not!

Just remember that it isn’t perfect, certainly from the eyes of an SEO pro - It can’t be parsed progressively, unlike HTML and CSS, and it can be heavy on page load and therefore performance. In many cases, you may be trading performance for functionality…

How Google Crawls Javascript On Websites

The truth is that it can never be guaranteed for Google to index your javascript. (It’s also worth noting that no one can guarantee google will index html for that matter either… but, one thing at a time!)

However, Google can index javascript on some websites a lot better than others. So what’s the difference? How can you ensure that your website stays ahead of your competitors?

The reason that Google can find indexing javascript a little harder than say HTML / CSS is that Googlebot has to use the Google Web Rendering Service to parse, compile and execute JavaScript. The web rendering service then has to fetch data from external APIs.

It’s a little like arriving at the supermarket, seeing the chocolate bar you want on the shelf, but before you can take it to the tills - a shop assistant has to go and fetch the barcode from their warehouse which is the other side of town… It’s just a long-winded process!

Of course, with slower loading times you risk high bounce rates and damaging user experience. This leads to bad news for your website and business, whether you have a small local business website or you're focussing on eCommerce SEO as an online retailer!

Checking Your Javascript SEO

There are 3 main factors to focus on with javascript SEO:

Crawlability - Allowing Google to crawl your website using a logical structure to find all of your focus information.

Renderability - Google should be able to render your website
Crawl budget - How much time it will take for Google to crawl and render your website.

Rendering JavaScript can affect your crawl budget and delay Google’s indexing of your pages. So it’s important to follow these steps:

Check If Google Can Render Your Site

It’s just not enough to open a browser and see if your website loads…

Use Google’s URL Inspection Tool, which is available through Search Console. It allows you to see a screenshot of how exactly Googlebot would render the JavaScript content on your page. So it’s incredibly useful.

When you view the screenshot, you’ll need to decide whether Google can see the crucial elements on your page, and if the main content is loaded prominently.

If you want to dive deeper, you can also take a look at the HTML tab within the generated report to see the DOM rendered code.

Check if Your Content is Indexed

The two best ways to check if your website is being indexed by Google are; using the ‘site:examplewebsite.com’ search command, and checking Google Search Console.

Unfortunately, a lot of the time, javascript SEO problems are self-induced - which is why it’s important to check on your website from the outset! If your website struggles with a problem you should find out why.

There’s multiple reasons why your site could be facing javascript SEO issues:

Timeouts - How long is Googlebot and your users waiting for your content to fully load?
Accessibility - Is your content accessible via your sitemap file?

Rendering - Can Google definitely render your scripts? Use the URL Inspection Tool previously mentioned.

Arrange A Technical SEO Audit

Whether you’re new to SEO or a seasoned vet - it can always help to get a second pair of eyes to look over your website from a technical SEO standpoint.

Nigel Adams is an experienced SEO freelancer based in the UK. Nigel runs a results-driven Bedford SEO Agency, with a small team. If you’re interested in a Technical SEO Audit for your website, he’s your go to guy!