How to Recover Custom Permalinks After Accidentally Regenerating Them in Permalink Manager Pro

1. Restore a pre-regenerate backup to a staging environment

Don’t restore directly to live. Spin up (or restore into) a staging copy of your site from a backup taken before you ran the regenerate tool. Most managed WordPress hosts (Kinsta, WP Engine, SiteGround, etc.) keep automatic daily snapshots — check there first.

2. Locate the option row on staging

SELECT option_name FROM wp_options WHERE option_name = ‘permalink-manager-uris’;

If that returns nothing, broaden the search:

SELECT option_name FROM wp_options WHERE option_value LIKE ‘%some-known-custom-slug%’;

Use an actual URL you know existed pre-regenerate as the search term — this is far more reliable than guessing option names.

3. Pull the full value from both staging and live

SELECT option_value FROM wp_options WHERE option_name = ‘permalink-manager-uris’;

Run this on both environments and save each result to its own text file (staging.txt and live.txt) — copy the value exactly, with no reformatting.

4. Don’t just overwrite live’s row with staging’s — merge them

This is the step that’s easy to get wrong. If any pages were published on live after your backup was taken, they won’t exist in the staging data at all — a straight overwrite would silently delete their custom permalinks too, even though the regenerate never touched them.

The right approach is a merge: for every post ID, use staging’s value (the correct, pre-regenerate URL) where it exists, but preserve any ID that’s only present in live (a newer page).

Here’s a small Python script to do this safely:

    import phpserialize

with open(‘staging.txt’, ‘rb’) as f:

    staging = phpserialize.loads(f.read())

with open(‘live.txt’, ‘rb’) as f:

    live = phpserialize.loads(f.read())

merged = dict(live)      # start with live’s current data

merged.update(staging)   # overwrite with staging’s values for any ID present in both

print(f”Staging entries: {len(staging)}”)

print(f”Live entries: {len(live)}”)

print(f”Merged entries: {len(merged)}”)

print(f”Changed (restored): {sum(1 for k in staging if k in live and live[k] != staging[k])}”)

output = phpserialize.dumps(merged)

with open(‘merged.txt’, ‘wb’) as f:

    f.write(output)

print(“Done — merged.txt is ready to use in the UPDATE statement.”)

Install the one dependency it needs first:

     pip install phpserialize

macOS tip: if you hit an externally-managed-environment error installing packages, use a virtual environment instead of forcing the install system-wide:

python3 -m venv venv

source venv/bin/activate

pip install phpserialize

python3 merge.py

The “Changed (restored)” number this script prints is also your answer to “how many URLs actually got affected by the regenerate” — a genuinely useful number to have before you tell anyone (your SEO team, stakeholders, etc.) the scope of the incident.

5. Sanity-check a few known URLs before writing anything

import phpserialize

with open(‘merged.txt’, ‘rb’) as f:

    merged = phpserialize.loads(f.read())

for pid in [3951, 5583]:  # replace with IDs you know

    print(pid, merged.get(pid, ‘NOT FOUND’))

Confirm the values match what you expect before moving to the write step.

6. Back up live’s current value first

Before writing anything, run the same SELECT on live one more time and save the output somewhere safe. This is your undo path if anything goes wrong.

7. Generate a properly-escaped SQL update, don’t hand-paste it

Serialized PHP strings are extremely sensitive to formatting — a single reformatted quote or line-wrap will corrupt the whole array and can white-screen your site. Generate the exact SQL with a script rather than typing it by hand:

with open(‘merged.txt’, ‘r’) as f:

    merged_value = f.read().strip()

escaped = merged_value.replace(“‘”, “””)

sql = f”UPDATE wp_options SET option_value = ‘{escaped}’ WHERE option_name = ‘permalink-manager-uris’;”

with open(‘update.sql’, ‘w’) as f:

    f.write(sql)

8. Run it on live, then flush and verify

Paste update.sql’s contents into your database tool’s SQL console (phpMyAdmin, Kinsta’s database manager, Adminer, etc.) and run it.

Then:

1. Go to Settings → Permalinksin wp-admin and click Save to flush rewrite rules.
2. Load a few of your known custom URLs directly in an incognito window to confirm they resolve.
3. Spot-check several more from your “changed” list at random, not just the ones you were originally tracking.