# Redirect Chain & Migration Map Checker (`digivibetech/redirect-chain-migration-checker`) Actor

Trace each redirect hop of your URLs (301, 302, 307, 308, meta refresh; up to 10 hops by default, 30 max), flag chains, loops, temporary redirects and http/https mix-ups, and check an old-to-new migration map against what the server really returns. $0.0005 per URL, no start fee.

- **URL**: https://apify.com/digivibetech/redirect-chain-migration-checker.md
- **Developed by:** [DigiVibeTech](https://apify.com/digivibetech) (community)
- **Categories:** SEO tools, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 url traced (redirect chain determined)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Redirect Chain & Migration Map Checker

**Redirect Chain & Migration Map Checker** — trace each redirect hop of your URLs (301, 302, 307, 308, meta refresh; up to 10 hops by default, 30 max), flag chains, loops, temporary redirects and http/https mix-ups, and check an old-to-new migration map against what the server really returns.

> **Try it free:** press **Start** — the prefilled input runs a small real job (up to 1 × url traced, about $0.0005 in events). Apify's free plan includes monthly platform credit, so a first test costs you nothing. You can also set a maximum cost per run.

- **What you get:** `url`, `state`, `hops`, `firstStatus`, `finalStatus`, `finalUrl`
- **Who it's for:** SEO teams and developers running site migrations
- **Price:** $0.0005 per url traced
- **Data source:** Requests only the URLs you supply.

### What is Redirect Chain & Migration Map Checker?

Paste a list of URLs or your **old -> new redirect plan** and see exactly what each server does: **each hop** (up to `maxHops`, default 10) with its status code and Location, the final URL and status, and a plain list of problems. Built for site migrations, domain moves, https switches and redirect clean-ups.

### ✅ Why this one

- Checks an old -> new migration map: each old URL (up to `maxUrls`, default 10,000) is traced and compared with the planned new URL, with `matchesExpected` and a plain `mapProblem`.
- Finds redirect loops, chains, meta refresh redirects, temporary 302/307 hops, https to http downgrades and redirects that end in 404 or 5xx.
- $0.0005 per URL with no start fee.
- MAP_REPORT (CSV) opens in any spreadsheet, and ISSUES lists only the URLs with problems.

### Migration map check

Give each old URL the new URL you planned (`old -> new` lines, or paste a two-column CSV). Each old URL is traced (up to `maxUrls`, default 10,000; hops disallowed by robots.txt are skipped and not charged) and its final URL is compared with your plan. Each row gets `matchesExpected` and, when it does not match, a `mapProblem`: old URL does not redirect, ends in HTTP 404, or redirects to a different URL than planned. Options let you ignore a trailing slash, the query string, http vs https or upper/lower case. Use `baseUrl` to write short paths such as `/old-page`.

The **MAP_REPORT** record (CSV) is ready to open in a spreadsheet, and **ISSUES** lists only the URLs with problems.

### 📸 Real-run screenshots

Apify Console views of a 10 November 2026 cloud run of the example input above.

![Apify Console output table of the 10 November 2026 run, with 6 traced URLs and their state, status and map result](https://api.apify.com/v2/key-value-stores/8dx7mDMr71NbvtKdp/records/redirect-chain-migration-checker-proof-01-console-run-output-l26.png)

![Apify Console run page of that run: status Succeeded, the status message with 6 traced URLs and 3 of 6 map matches, and the run log](https://api.apify.com/v2/key-value-stores/8dx7mDMr71NbvtKdp/records/redirect-chain-migration-checker-proof-02-console-run-log-l26.png)

### ⬇️ What data you get

- **Chains**: more than one hop before the final page (each extra hop costs crawl budget and speed). You choose the length that counts as a chain.
- **Loops**: A -> B -> A, or a URL redirecting to itself.
- **Temporary redirects** (302, 303, 307) where a permanent 301/308 is usual.
- **https to http downgrades** and **mixed http/https hops**.
- **Cross-domain** redirects and **dropped query strings**.
- **Meta refresh** redirects (`<meta http-equiv="refresh">`), followed like normal hops.
- **Broken targets**: redirects that end in 404, 410 or 5xx.

### 🎯 Use cases

- Check an old-to-new URL map after a migration
- Find redirect chains, loops and 302s that should be 301s
- Catch http/https mix-ups

### ▶️ How to use

1. Open the actor; the input is prefilled with a small real example.
2. Replace it with your own input and set `maxChainHops` to control the cost.
3. Press **Start**. Results appear in the **Output** tab (Overview view).
4. Download JSON, CSV or Excel, call the results via API, or schedule the actor.

### ⚙️ Input

| Field | Default | Meaning |
|---|---|---|
| `urls` | | URLs to trace |
| `migrationMap` / `migrationMapCsv` | | Old -> new pairs to verify |
| `baseUrl` | | Base for relative paths |
| `ignoreTrailingSlash` | true | Compare /page and /page/ as equal |
| `ignoreQuery`, `ignoreScheme`, `ignoreCase` | false | Looser comparison |
| `detectMetaRefresh` | true | Follow meta refresh (reads at most 64 KB of the final page) |
| `maxChainHops` | 1 | Flag redirects with more hops than this |
| `maxHops` | 10 | Stop after this many hops |
| `maxUrls` | 10000 | Most URLs per run |

#### Example input

```json
{
  "migrationMap": [
    "https://www.iana.org/help/example-domains -> https://www.iana.org/help/example-domains",
    "https://iana.org/ -> https://www.iana.org/",
    "https://www.iana.org/help/ -> https://www.iana.org/domains/reserved",
    "https://www.iana.org/domains/example -> https://www.iana.org/help/example-domains",
    "https://www.iana.org/help/does-not-exist -> https://www.iana.org/help",
    "https://digivibetech.com/support -> https://digivibetech.com/support/"
  ],
  "maxUrls": 6
}
```

### ⬆️ Output

One row per URL: `url`, `state` (no redirect, redirect, chain, loop, too many hops, broken, unreachable), `hops`, `firstStatus`, `finalStatus`, `finalUrl`, `chain` (each hop followed, up to `maxHops`: url, status, location, kind http or meta), `issues`, `ok`, and for map rows `expectedUrl`, `matchesExpected`, `mapProblem`. SUMMARY has the counts.

#### Example output

Real rows from an Apify cloud run on 10 November 2026, using the example input above with all other settings at their defaults (meta refresh detection on). Two rows were planned to fail on purpose: `/help/` is mapped to a different page, and `/help/does-not-exist` is a page that does not exist. All 6 URLs were traced and charged as 6 `url-traced` events. SUMMARY reported 3 map matches and 3 mismatches, 1 broken URL and 3 URLs with issues. The `/domains/example` row was not planned to fail: on that date the server sent it to the `http://` address, so it is reported as an https to http downgrade that does not match the planned `https://` URL.

| `url` | `state` | `firstStatus` | `finalStatus` | `finalUrl` | `expectedUrl` | `matchesExpected` | `issues` / `mapProblem` |
|---|---|---|---|---|---|---|---|
| https://www.iana.org/help/example-domains | no redirect | 200 | 200 | https://www.iana.org/help/example-domains | https://www.iana.org/help/example-domains | true | none |
| https://iana.org/ | redirect | 301 | 200 | https://www.iana.org/ | https://www.iana.org/ | true | none |
| https://www.iana.org/help/ | redirect | 302 | 200 | https://www.iana.org/help | https://www.iana.org/domains/reserved | false | temporary redirect (302) where a permanent 301/308 is usual; does not match the migration map / redirects to a different URL than planned |
| https://www.iana.org/domains/example | redirect | 301 | 200 | http://www.iana.org/help/example-domains | https://www.iana.org/help/example-domains | false | https to http downgrade; does not match the migration map / redirects to a different URL than planned |
| https://www.iana.org/help/does-not-exist | broken | 404 | 404 | https://www.iana.org/help/does-not-exist | https://www.iana.org/help | false | final URL returns HTTP 404; does not match the migration map / ends in HTTP 404 |
| https://digivibetech.com/support | redirect | 308 | 200 | https://digivibetech.com/support/ | https://digivibetech.com/support/ | true | none |

The downgrade row as it appears in the dataset:

```json
{
  "url": "https://www.iana.org/domains/example",
  "state": "redirect",
  "hops": 1,
  "finalUrl": "http://www.iana.org/help/example-domains",
  "finalStatus": 200,
  "firstStatus": 301,
  "chain": [
    {
      "url": "https://www.iana.org/domains/example",
      "status": 301,
      "location": "http://www.iana.org/help/example-domains",
      "kind": "http"
    }
  ],
  "issues": [
    "https to http downgrade",
    "does not match the migration map"
  ],
  "ok": false,
  "error": null,
  "expectedUrl": "https://www.iana.org/help/example-domains",
  "matchesExpected": false,
  "mapProblem": "redirects to a different URL than planned",
  "checkedAt": "2026-11-10T08:19:41.721717+00:00"
}
```

These rows show what those servers returned on that date. Redirects can change, so run the actor again for a current result.

### 💵 Pricing and cost estimate

| Event | Price |
|---|---|
| URL traced (redirect chain determined) | $0.0005 |

All hops of a URL are included in one charge. URLs skipped by robots.txt are free and there is no start fee. A 2,000-URL migration map costs at most $1.00 (URLs skipped by robots.txt are free). Set a maximum cost per run and the actor stops before going over it; URLs it did not trace are not charged.

#### Cost estimate

| Url traceds | Cost |
|---|---|
| 100 | $0.050 |
| 1,000 | $0.50 |
| 10,000 | $5.00 |

You pay only for these events: no subscription.

### 🔌 Integrations and API

Run it from **n8n, Make, Zapier, Clay** or any tool that can call an HTTP endpoint, connect a **webhook** to get notified when a run finishes, or let AI agents call it through the **Apify MCP server** (`mcp.apify.com`).

Run it and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/digivibetech~redirect-chain-migration-checker/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://iana.org/", "https://www.iana.org/help/"], "migrationMap": ["https://iana.org/ -> https://www.iana.org/"], "maxChainHops": 1}'
```

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("digivibetech/redirect-chain-migration-checker").call(run_input={"urls": ["https://iana.org/", "https://www.iana.org/help/"], "migrationMap": ["https://iana.org/ -> https://www.iana.org/"], "maxChainHops": 1})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### Use it with Make, Zapier or a webhook

Run it after each deploy with your redirect map, then read `MAP_REPORT` (`/key-value-stores/{id}/records/MAP_REPORT`) or `ISSUES` and alert your team when it is not empty.

### ⚠️ Limits

- It reads HTTP responses and meta refresh tags, not JavaScript redirects (`window.location`), which need a browser.
- Each host gets about one request per second, so 1,000 URLs on one site take roughly 15-30 minutes; many hosts run in parallel.
- Servers that block automated requests may answer 403 or 429 instead of their real redirect.
- A URL in both lists is traced once, with its map check.

### 🛡️ Data source, privacy and legality

Requests only the URLs you supply.

#### Responsible use

Each hop it follows (up to `maxHops`) is checked against that site's **robots.txt** (disallowed hops are not requested and not charged), each host gets about one request per second, the User-Agent is honest (`RedirectChainChecker/1.0`), and the actor never logs in, uses proxies or bypasses bot protection. Check sites you own or are allowed to check. Only URLs, status codes and redirect targets are stored, not page content. URLs and query strings can contain personal data, so do not submit personal or confidential values.

#### Data processing

- **What it requests:** each URL you submit, and each redirect target it leads to, one hop at a time. Requests are HEAD, or GET when `detectMetaRefresh` is on; then at most 64 KB of an HTML page is read to find a meta refresh tag, and the page body is not saved. Before the first hop on a site it reads that site's `robots.txt` and skips any hop it disallows. Every request this actor sends to a checked site, both each hop and each robots.txt fetch, uses the User-Agent `RedirectChainChecker/1.0 (Apify Actor; check requested by the run's user; +https://apify.com)`, so each checked server sees the requested URL and that User-Agent; its calls to the Apify platform for storage and billing go through the Apify SDK. URLs containing login credentials and URLs that point to private or local network addresses are refused and not requested.
- **What it stores:** one dataset row per traced URL (URLs, each followed hop's status code and Location, final URL and status, issues, map fields and a `checkedAt` time), plus the key-value records SUMMARY and OUTPUT (counts), ISSUES (rows with problems), ERRORS (skipped or failed inputs) and MAP_REPORT (CSV, when a map is given). No page content is stored.
- **Personal data:** URLs and query strings are stored as you submit them and as servers return them, and they can contain personal data. Do not submit credentials, private URLs or confidential values.
- **Where it runs and how long data is kept:** on Apify, which processes the input, run metadata, logs, dataset, key-value store and pay-per-event accounting. Results go to the run's default storage; the actor sets no deletion period of its own, so retention follows your Apify plan and settings ([Apify storage and retention](https://docs.apify.com/storage#data-retention)). Download what you need and do not share storage IDs or access links.
- **Billing:** one `url-traced` event at $0.0005 per URL, charged after its row is saved. URLs skipped by robots.txt are not charged. See [pay-per-event](https://docs.apify.com/actors/monetize/pay-per-event). No seven-day free actor-run window or separate product key applies.
- **Questions and privacy requests:** [DigiVibeTech support](https://digivibetech.com/support/). The DigiVibeTech [website privacy policy](https://digivibetech.com/privacy/) covers the website and support; this section covers what the actor itself processes.

### ❓ FAQ

#### How much does Redirect Chain & Migration Map Checker cost?

$0.0005 per url traced. See the cost estimate table above. There is no monthly fee.

#### Can I try it for free?

Yes. Press Start with the prefilled input: it runs a small real job (up to 1 × url traced, about $0.0005 in events). Apify's free plan includes monthly platform credit, which covers a first test.

#### Is it legal to use Redirect Chain & Migration Map Checker?

Requests only the URLs you supply. Use the results lawfully (terms of the source, GDPR where it applies). This is not legal advice.

#### Can I use it through the API or an MCP server?

Yes. Every run is available through the Apify API and the official client libraries, and AI agents can call the actor through the Apify MCP server. See Integrations and API above.

#### Something does not work. Where do I get help?

Open an issue on the Issues tab or use [digivibetech.com/support](https://digivibetech.com/support/). Include the run ID so we can reproduce it.

### 📝 Changelog

#### 20 Nov 2026 — listing refresh

- README, listing text and input form restructured to the DigiVibeTech Apify quality standard v1. No feature or price change.

#### 1.0 — builds 1.0.1 to 1.0.6

- First build 2026-10-26, latest build 2026-11-10 (6 successful builds).

### 🧩 More DigiVibeTech actors

- [Website SEO & AI Search Audit (GEO/AEO)](https://apify.com/digivibetech/ai-search-citation-readiness)
- [Broken Link & Image Checker - Sitemap or Crawl](https://apify.com/digivibetech/broken-link-image-checker)
- [Bulk WHOIS & DNS Lookup - Domain Expiry, RDAP, SPF, DMARC](https://apify.com/digivibetech/domain-whois-rdap-dns)
- [Schema Markup Extractor & Validator - JSON-LD, Open Graph](https://apify.com/digivibetech/schema-markup-metadata-extractor)

*Maintained by DigiVibeTech. Questions or bugs: use the Issues tab or [digivibetech.com/support](https://digivibetech.com/support/); we reply within 2–5 business days.*

# Changelog

This Actor's version history is a separate document: https://apify.com/digivibetech/redirect-chain-migration-checker/changelog.md

# Actor input Schema

## `urls` (type: `array`):

URLs to follow hop by hop. Without http(s):// they are read as https://. Public URLs only; robots.txt is respected.

## `migrationMap` (type: `array`):

One line per redirect you planned: 'old URL -> new URL' (a comma, tab or space between them also works). Each old URL is traced and its final URL compared with the new one.

## `migrationMapCsv` (type: `string`):

Paste a two-column CSV (old URL, new URL), for example exported from a spreadsheet. A header row is skipped.

## `ignoreTrailingSlash` (type: `boolean`):

Treat /page and /page/ as the same URL in the migration map check.

## `ignoreQuery` (type: `boolean`):

Compare final and planned URLs without their ?query part.

## `ignoreScheme` (type: `boolean`):

Count http:// and https:// as the same in the migration map check.

## `ignoreCase` (type: `boolean`):

Compare URL paths case-insensitively.

## `detectMetaRefresh` (type: `boolean`):

Also follow <meta http-equiv=refresh> redirects. Reads at most 64 KB of each final HTML page. Off = HEAD requests only (faster).

## `maxChainHops` (type: `integer`):

A redirect with more hops than this is flagged as a chain. 1 = flag anything over one hop.

## `maxHops` (type: `integer`):

Stop following after this many hops and report 'too many hops'.

## `maxUrls` (type: `integer`):

Most URLs traced in this run. Each traced URL is one charged event; URLs skipped by robots.txt or not reached are free.

## `baseUrl` (type: `string`):

Lets you write /old-page instead of full URLs in the lists above, such as https://www.iana.org.

## Actor input object example

```json
{
  "urls": [
    "https://iana.org/",
    "https://www.iana.org/help/"
  ],
  "migrationMap": [
    "https://iana.org/ -> https://www.iana.org/"
  ],
  "ignoreTrailingSlash": true,
  "ignoreQuery": false,
  "ignoreScheme": false,
  "ignoreCase": false,
  "detectMetaRefresh": true,
  "maxChainHops": 1,
  "maxHops": 10,
  "maxUrls": 10000
}
```

# Actor output Schema

## `results` (type: `string`):

All result items (overview view)

## `errors` (type: `string`):

Inputs that could not be processed, with the reason

## `summary` (type: `string`):

Counts of processed, billed and failed items

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://iana.org/",
        "https://www.iana.org/help/"
    ],
    "migrationMap": [
        "https://iana.org/ -> https://www.iana.org/"
    ],
    "maxChainHops": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("digivibetech/redirect-chain-migration-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": [
        "https://iana.org/",
        "https://www.iana.org/help/",
    ],
    "migrationMap": ["https://iana.org/ -> https://www.iana.org/"],
    "maxChainHops": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("digivibetech/redirect-chain-migration-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://iana.org/",
    "https://www.iana.org/help/"
  ],
  "migrationMap": [
    "https://iana.org/ -> https://www.iana.org/"
  ],
  "maxChainHops": 1
}' |
apify call digivibetech/redirect-chain-migration-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,digivibetech/redirect-chain-migration-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/OUe2yytdc2BQ3neZl/builds/aOTiUTk1lbg2YP6aG/openapi.json
