Firefox : tester les liens avec GreaseMonkey

Il y a quelques années, on utilisait Firefox et Greasemonkey pour vérifier automatiquement si des liens RapidShare, MegaUpload, Netload ou FileFactory étaient encore actifs. C’était l’époque des hébergeurs de fichiers, des pages remplies de liens miroirs, et des scripts bricolés qui faisaient gagner un temps fou.

Aujourd’hui, le besoin a changé. RapidShare et MegaUpload appartiennent au musée du web, juste à côté des boutons “Download” qui clignotent en vert fluo. En revanche, tester rapidement les liens d’une page reste très utile.

Vous pouvez vous en servir pour vérifier :

les liens sortants d’un article ;
les liens internes d’une page WordPress ;
les ressources citées dans un tutoriel ;
les liens d’une page de téléchargement ;
les liens affiliés ;
les anciennes URLs d’un article avant refonte ;
les erreurs 404 visibles depuis une page précise.

Voici une méthode moderne pour tester les liens d’une page avec Firefox, un gestionnaire de userscripts et un petit script JavaScript.

Kinsta: Premium Managed WordPress hosting

Greasemonkey, Violentmonkey ou Tampermonkey ?

Greasemonkey reste l’extension historique de Firefox pour exécuter des userscripts. Un userscript est un petit script JavaScript qui modifie ou enrichit une page web côté navigateur.

Mais pour un usage actuel, je recommande plutôt Violentmonkey si vous voulez une solution open source, moderne et compatible avec beaucoup de scripts existants. Tampermonkey reste aussi une option solide si vous préférez son interface et son écosystème.

Extension	Avantage	Remarque
Greasemonkey	Extension historique Firefox	Simple, mais compatibilité parfois moins confortable avec certains scripts modernes.
Violentmonkey	Open source, compatible Greasemonkey/Tampermonkey	Très bon choix pour Firefox, Chrome, Edge et navigateurs WebExtensions.
Tampermonkey	Interface complète, très répandu	Pratique pour gérer beaucoup de scripts et profils.

Pour ce guide, j’utilise Violentmonkey, mais le script peut aussi être adapté à Tampermonkey.

Installer Violentmonkey dans Firefox

Ouvrez Firefox.
Allez sur la page officielle de Violentmonkey dans les modules Firefox.
Cliquez sur Ajouter à Firefox.
Validez l’installation.
Épinglez l’icône de l’extension si vous voulez y accéder rapidement.

Une fois installé, Violentmonkey permet de créer, modifier, activer, désactiver, importer et exporter des userscripts. Vous pouvez aussi limiter les scripts à certains domaines, ce que je recommande fortement.

BigScoots: Premium WordPress and WooCommerce hosting

Pourquoi ne pas tester tous les liens depuis une page web classique ?

Un script exécuté directement dans une page web rencontre vite des limites. Les navigateurs bloquent souvent les requêtes vers d’autres domaines à cause des règles CORS. C’est normal : une page ne doit pas pouvoir interroger librement tout le web depuis votre navigateur.

Un gestionnaire de userscripts peut utiliser des fonctions spéciales comme GM_xmlhttpRequest, qui permettent de faire des requêtes plus adaptées à ce type d’outil. C’est précisément ce qui rend un userscript plus pratique qu’un simple bout de JavaScript collé dans la console.

Il reste tout de même des limites :

certains serveurs bloquent les requêtes HEAD ;
certains sites bloquent les requêtes automatisées ;
certains liens exigent une authentification ;
les redirections peuvent masquer le vrai statut final ;
un lien peut répondre 200 mais afficher une page d’erreur ;
tester trop de liens à la fois peut déclencher un rate limit.

Ce script sert donc à faire un contrôle rapide sur une page, pas un audit SEO complet de tout un site.

Créer un script de test de liens

Dans Violentmonkey :

cliquez sur l’icône Violentmonkey ;
choisissez Créer un nouveau script ;
supprimez le contenu proposé ;
collez le script ci-dessous ;
enregistrez.

// ==UserScript==
// @name         Sky Link Checker
// @namespace    https://www.skyminds.net/
// @version      1.0.0
// @description  Vérifie les liens présents sur la page courante et affiche leur statut HTTP.
// @author       SkyMinds
// @match        *://*/*
// @grant        GM_xmlhttpRequest
// @grant        GM_registerMenuCommand
// @connect      *
// ==/UserScript==

(function () {
	'use strict';

	const BADGE_CLASS = 'sky-link-checker-badge';
	const CHECKED_ATTRIBUTE = 'data-sky-link-checker-status';
	const MAX_CONCURRENT_REQUESTS = 5;
	const REQUEST_TIMEOUT_MS = 10000;

	const ignoredProtocols = [
		'mailto:',
		'tel:',
		'sms:',
		'javascript:',
		'data:',
		'blob:',
	];

	/**
	 * Check whether a URL should be ignored.
	 *
	 * @param {HTMLAnchorElement} link Link element.
	 * @return {boolean} True when the link should be ignored.
	 */
	function shouldIgnoreLink(link) {
		const href = link.getAttribute('href');

		if (!href || href.startsWith('#')) {
			return true;
		}

		const normalisedHref = href.trim().toLowerCase();

		return ignoredProtocols.some((protocol) => normalisedHref.startsWith(protocol));
	}

	/**
	 * Create a small badge next to a link.
	 *
	 * @param {HTMLAnchorElement} link Link element.
	 * @param {string} text Badge text.
	 * @param {string} type Badge type.
	 * @return {void}
	 */
	function addBadge(link, text, type) {
		const existingBadge = link.parentNode?.querySelector(
			`:scope > .${BADGE_CLASS}[data-sky-link="${CSS.escape(link.href)}"]`
		);

		if (existingBadge) {
			existingBadge.textContent = text;
			existingBadge.dataset.type = type;
			return;
		}

		const badge = document.createElement('span');

		badge.className = BADGE_CLASS;
		badge.dataset.type = type;
		badge.dataset.skyLink = link.href;
		badge.textContent = text;
		badge.title = `Statut du lien : ${text}`;

		link.insertAdjacentElement('afterend', badge);
	}

	/**
	 * Inject badge styles once.
	 *
	 * @return {void}
	 */
	function injectStyles() {
		if (document.getElementById('sky-link-checker-styles')) {
			return;
		}

		const style = document.createElement('style');

		style.id = 'sky-link-checker-styles';
		style.textContent = `
			.${BADGE_CLASS} {
				display: inline-block;
				margin-left: .35rem;
				padding: .1rem .35rem;
				border-radius: .35rem;
				font: 600 11px/1.4 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
				vertical-align: middle;
				background: #e5e7eb;
				color: #111827;
			}

			.${BADGE_CLASS}[data-type="ok"] {
				background: #dcfce7;
				color: #166534;
			}

			.${BADGE_CLASS}[data-type="redirect"] {
				background: #fef9c3;
				color: #854d0e;
			}

			.${BADGE_CLASS}[data-type="error"] {
				background: #fee2e2;
				color: #991b1b;
			}

			.${BADGE_CLASS}[data-type="unknown"] {
				background: #e0f2fe;
				color: #075985;
			}
		`;

		document.head.appendChild(style);
	}

	/**
	 * Request an URL with HEAD first.
	 *
	 * Some servers reject HEAD requests. In that case, we retry with GET.
	 *
	 * @param {string} url URL to check.
	 * @param {string} method HTTP method.
	 * @return {Promise<{status: number, finalUrl: string}>} Response data.
	 */
	function requestUrl(url, method = 'HEAD') {
		return new Promise((resolve, reject) => {
			GM_xmlhttpRequest({
				method,
				url,
				timeout: REQUEST_TIMEOUT_MS,
				onload: (response) => {
					resolve({
						status: response.status,
						finalUrl: response.finalUrl || url,
					});
				},
				ontimeout: () => reject(new Error('timeout')),
				onerror: () => reject(new Error('network error')),
			});
		});
	}

	/**
	 * Check one link and update its badge.
	 *
	 * @param {HTMLAnchorElement} link Link element.
	 * @return {Promise<void>} Promise.
	 */
	async function checkLink(link) {
		addBadge(link, '…', 'unknown');

		try {
			let response = await requestUrl(link.href, 'HEAD');

			if ([405, 403, 0].includes(response.status)) {
				response = await requestUrl(link.href, 'GET');
			}

			const status = response.status;
			let type = 'unknown';

			if (status >= 200 && status < 300) {
				type = 'ok';
			} else if (status >= 300 && status < 400) {
				type = 'redirect';
			} else if (status >= 400) {
				type = 'error';
			}

			link.setAttribute(CHECKED_ATTRIBUTE, String(status));
			addBadge(link, String(status), type);
		} catch (error) {
			link.setAttribute(CHECKED_ATTRIBUTE, 'failed');
			addBadge(link, 'ERR', 'error');
		}
	}

	/**
	 * Run promises with a concurrency limit.
	 *
	 * @param {HTMLAnchorElement[]} links Links to process.
	 * @return {Promise<void>} Promise.
	 */
	async function checkLinksWithLimit(links) {
		const queue = [...links];
		const workers = Array.from({ length: MAX_CONCURRENT_REQUESTS }, async () => {
			while (queue.length > 0) {
				const link = queue.shift();

				if (link) {
					await checkLink(link);
				}
			}
		});

		await Promise.all(workers);
	}

	/**
	 * Start the link checker.
	 *
	 * @return {void}
	 */
	function startLinkChecker() {
		injectStyles();

		const links = Array.from(document.querySelectorAll('a[href]'))
			.filter((link) => !shouldIgnoreLink(link));

		if (links.length === 0) {
			alert('Aucun lien testable trouvé sur cette page.');
			return;
		}

		checkLinksWithLimit(links);
	}

	GM_registerMenuCommand('Tester les liens de cette page', startLinkChecker);
})();Langage du code : JavaScript (javascript)

Une fois le script installé, ouvrez une page web, cliquez sur l’icône Violentmonkey, puis lancez Tester les liens de cette page. Le script ajoute un petit badge à côté de chaque lien avec le statut HTTP obtenu.

Comprendre les statuts affichés

Badge	Signification	Action
`200`	Le lien répond correctement.	Rien à corriger en général.
`301` ou `302`	Le lien redirige.	Vérifiez si la redirection est souhaitée.
`403`	Accès refusé.	Le site bloque peut-être les requêtes automatisées.
`404`	Page introuvable.	Corrigez ou remplacez le lien.
`410`	Contenu supprimé définitivement.	Remplacez le lien si la ressource était utile.
`429`	Trop de requêtes.	Réduisez la fréquence ou testez plus tard.
`500` à `599`	Erreur serveur.	Retestez plus tard ou remplacez la source.
`ERR`	Échec réseau, timeout ou blocage.	Vérifiez manuellement.

Un statut 200 ne garantit pas toujours que le contenu est correct. Certains sites renvoient une page d’erreur avec un statut 200. Oui, c’est moche. Oui, ça arrive souvent.

Le plus lu : WordPress : réduire le nombre de requêtes SQL des thèmes

Limiter le script à vos propres sites

Le script ci-dessus utilise :

// @match        *://*/*
// @connect      *Langage du code : JSON / JSON avec commentaires (json)

C’est pratique pour tester rapidement sur n’importe quelle page, mais c’est très large. Si vous voulez l’utiliser seulement sur votre site, limitez le script à votre domaine.

Par exemple, pour SkyMinds :

// @match        https://www.skyminds.net/*
// @connect      www.skyminds.net
// @connect      skyminds.netLangage du code : JSON / JSON avec commentaires (json)

Vous pouvez aussi ajouter les domaines externes que vous testez souvent :

// @connect      developer.wordpress.org
// @connect      support.mozilla.org
// @connect      github.comLangage du code : JSON / JSON avec commentaires (json)

C’est plus propre, plus lisible, et cela évite de donner au script une portée plus large que nécessaire.

WPEngine: Premium Managed WooCommerce hosting

Tester uniquement les liens internes

Si vous voulez vérifier uniquement les liens internes d’une page, remplacez la sélection des liens dans le script par cette version :

const links = Array.from(document.querySelectorAll('a[href]'))
	.filter((link) => !shouldIgnoreLink(link))
	.filter((link) => link.hostname === window.location.hostname);Langage du code : JavaScript (javascript)

C’est utile pour relire un article WordPress avant publication ou après refonte. Vous pouvez alors vérifier rapidement si un lien interne pointe vers une page qui répond encore.

Tester uniquement les liens externes

Pour tester seulement les liens sortants, utilisez plutôt :

const links = Array.from(document.querySelectorAll('a[href]'))
	.filter((link) => !shouldIgnoreLink(link))
	.filter((link) => link.hostname !== window.location.hostname);Langage du code : JavaScript (javascript)

C’est pratique pour les articles techniques avec beaucoup de sources, documentations, dépôts GitHub ou pages officielles.

Pourquoi certains liens affichent ERR alors qu’ils fonctionnent ?

Un badge ERR ne veut pas forcément dire que le lien est mort. Cela peut indiquer :

un timeout ;
un blocage anti-bot ;
un serveur qui refuse les requêtes HEAD et GET automatisées ;
une extension de confidentialité qui bloque la requête ;
une politique réseau stricte ;
un certificat TLS problématique ;
un site qui exige des cookies ou une session.

Le plus lu : Créer sa propre webradio avec Winamp et SHOUTcast

Le script donne donc une indication. Pour les liens importants, ouvrez-les manuellement avant de les supprimer.

Éviter de tester trop vite trop de liens

Le script limite déjà le nombre de requêtes simultanées avec cette constante :

const MAX_CONCURRENT_REQUESTS = 5;Langage du code : JavaScript (javascript)

Si une page contient beaucoup de liens externes, vous pouvez réduire la valeur :

const MAX_CONCURRENT_REQUESTS = 2;Langage du code : JavaScript (javascript)

C’est plus lent, mais plus discret. Tester 200 liens externes en parallèle depuis votre navigateur, c’est le genre d’idée qui finit en 429 Too Many Requests, puis en “pourquoi plus rien ne répond ?”.

Cas WordPress : vérifier les liens d’un article avant publication

Ce userscript est très utile dans un workflow éditorial WordPress.

Prévisualisez l’article.
Lancez le test de liens depuis Violentmonkey.
Corrigez les erreurs 404.
Vérifiez les redirections inutiles.
Remplacez les sources mortes.
Publiez seulement après vérification.

Pour les articles techniques, c’est particulièrement important. Un tutoriel qui pointe vers une documentation morte ou un dépôt GitHub disparu inspire rarement confiance. Et Google n’aime pas spécialement les cimetières de liens non plus.

Ce que ce script ne remplace pas

Ce script teste les liens visibles sur une page. Il ne remplace pas :

un crawl complet de site ;
un audit SEO ;
un outil comme Screaming Frog ou Sitebulb ;
les rapports d’indexation de Google Search Console ;
une vérification serveur des redirections ;
un audit WordPress des liens internes.

Pour une page isolée, le userscript est rapide. Pour un site entier, utilisez un crawler. Chaque outil a son terrain. Le tournevis reste excellent, mais il ne devient pas une perceuse par conviction personnelle.

Alternative en ligne de commande avec curl

Si vous préférez tester quelques liens depuis un terminal, curl suffit :

curl -I https://www.example.com/Langage du code : JavaScript (javascript)

Pour suivre les redirections :

curl -IL https://www.example.com/Langage du code : JavaScript (javascript)

Pour afficher uniquement le statut HTTP final :

curl -L -o /dev/null -s -w "%{http_code} %{url_effective}\n" https://www.example.com/Langage du code : JavaScript (javascript)

Cette méthode est excellente pour tester une URL précise. Le userscript est plus confortable pour inspecter toute une page visuellement.

Le plus lu : HADOPI : le gouvernement contre-attaque

Alternative WordPress : éviter les plugins lourds de broken links

Sur WordPress, il existe des plugins de vérification de liens cassés. Ils peuvent être pratiques, mais certains scannent beaucoup, écrivent en base, déclenchent des requêtes régulières et ralentissent l’administration.

Pour un site performant, je préfère souvent :

un crawler externe lancé ponctuellement ;
une vérification manuelle avant publication ;
un script CLI dédié ;
Google Search Console pour les erreurs d’indexation ;
des redirections propres côté serveur ou plugin léger.

Le userscript présenté ici s’intègre bien dans cette approche : il vérifie rapidement une page sans ajouter une extension WordPress permanente.

Sécurité : attention aux scripts récupérés en ligne

Un userscript peut lire et modifier les pages sur lesquelles il s’exécute. Il peut aussi envoyer des requêtes réseau si vous lui donnez les permissions nécessaires.

Installez donc uniquement des scripts que vous comprenez ou provenant de sources fiables. Relisez les métadonnées en haut du fichier, notamment :

@match ;
@include ;
@grant ;
@connect ;
@require.

Un script limité à votre site est beaucoup plus sain qu’un script autorisé à tourner partout. La paresse dans les permissions, c’est souvent le début des ennuis.

Besoin d’aide pour auditer les liens et le SEO technique de votre site ?

Besoin d’un développeur WordPress pour auditer vos liens ?

Si votre site contient beaucoup d’anciens articles, de liens externes, de redirections, d’erreurs 404 ou de ressources obsolètes, je peux vous aider à remettre tout ça au propre.

J’interviens comme développeur WordPress et WooCommerce pour auditer les liens internes, corriger les erreurs 404, nettoyer les redirections, améliorer le maillage interne et fiabiliser la structure technique du site.

Audit des liens internes, sortants, 404, 301 et chaînes de redirection.
Correction des URLs obsolètes dans les articles WordPress.
Nettoyage des redirections et amélioration du maillage interne.
Contrôle SEO technique avec crawl, logs, Search Console et WP-CLI.
Intervention propre, testée et documentée.

Vous voulez éviter que vos vieux liens transforment votre site en brocante numérique ? Contactez-moi. Je vous aiderai à corriger les liens qui comptent vraiment.

Checklist rapide

Installer Violentmonkey ou Tampermonkey dans Firefox.
Créer un nouveau userscript.
Coller le script de vérification des liens.
Limiter @match et @connect si possible.
Ouvrir la page à vérifier.
Lancer Tester les liens de cette page.
Corriger les liens 404, 410 et erreurs évidentes.
Vérifier manuellement les liens marqués ERR.
Contrôler les redirections 301 ou 302 importantes.
Utiliser un crawler dédié pour un audit complet du site.

FAQ : tester les liens avec Firefox et un userscript

Greasemonkey fonctionne-t-il encore avec Firefox ?

Oui. Greasemonkey existe toujours pour Firefox et permet d’exécuter des userscripts. Pour une compatibilité plus large avec les scripts modernes, Violentmonkey ou Tampermonkey sont souvent plus confortables.

Pourquoi utiliser Violentmonkey plutôt que Greasemonkey ?

Violentmonkey est open source, compatible avec les navigateurs WebExtensions, et prend en charge beaucoup de scripts écrits pour Greasemonkey ou Tampermonkey. C’est un bon choix moderne pour Firefox.

Le script peut-il tester tous les liens d’un site ?

Non. Il teste les liens présents sur la page ouverte. Pour un site entier, utilisez un crawler SEO ou un outil d’audit spécialisé.

Pourquoi certains liens affichent ERR alors qu’ils marchent dans le navigateur ?

Certains serveurs bloquent les requêtes automatisées, refusent les requêtes HEAD, exigent des cookies, ou limitent les accès. Ouvrez toujours les liens importants manuellement avant de les supprimer.

Un statut 301 est-il une erreur ?

Pas forcément. Une redirection 301 peut être normale. Mais si vous contrôlez le lien, mieux vaut souvent pointer directement vers l’URL finale pour éviter une redirection inutile.

Puis-je utiliser ce script pour vérifier mes articles WordPress ?

Oui. Prévisualisez l’article, lancez le script, puis corrigez les erreurs visibles avant publication. C’est particulièrement utile pour les articles techniques avec beaucoup de sources externes.

Sources

Report a typo

Facebook Tweet Pin LinkedIn

4 pensées sur “Tester les liens d’une page avec Firefox et un userscript”

agatzebluz

21 octobre à 21:44

Ces scripts greasemonkey, c’est tout simplement un bonheur !!!
Je les utilise pour d’autre sites.
Au passage, l’extension greasefire permet de ne pas chercher dans tous les sens puisqu’elle propose les scripts adaptés au site sur lequel on surfe. Malin !!! Mais leur nombre donne le tournis …
Répondre
Matt

23 octobre à 13:50

Merci Agat’ – par contre greasefire envoie la liste des sites que tu consultes à un serveur pour savoir s’il existe des scripts pour eux… pas glop.
Répondre
agatzebluz

23 octobre à 15:05

@ Matt : ben il suffit de l’activer / désactiver quand tu as un site sur lequel tu veux voir les scripts dispo.
Perso, j’ai fait comme ça. C’est pas super pratique, mais au moins ça allège FF et tu ne te traine pas ce boulet cafteur à la patte. ;-)
Répondre
Matt

23 octobre à 17:14

Ah ben oui, c’est vrai que les extensions GreaseMonkey s’activent et se désactivent en un clic, sans avoir à redémarrer Firefox.
Répondre

Tester les liens d’une page avec Firefox et un userscript