Audit automatisé des emplacements publicitaires avec Playwright : captures, nombre de blocs et statut de remplissage
L'essentiel
- Playwright est la bibliothèque open source d'automatisation de navigateur de Microsoft (Apache-2.0) ; la version 1.65.1 était la version courante sur npm en novembre 2026.
- page.route() peut interrompre les requêtes vers les domaines publicitaires de Google : un audit inspecte alors votre balisage et votre mise en page sans demander la moindre annonce.
- Un audit de mise en page peut compter les blocs ins.adsbygoogle, mesurer combien se trouvent dans le premier écran mobile, signaler les blocs sans hauteur réservée et vérifier que ads.txt est accessible.
- L'attribut data-ad-status n'est défini qu'une fois la requête d'annonce terminée : le statut de remplissage se collecte donc mieux auprès de vrais visiteurs avec un MutationObserver que lors de chargements automatisés.
- Un audit automatisé ne doit jamais cliquer sur des annonces ni charger de façon répétée des pages monétisées avec les annonces activées.

Playwright permet d’auditer automatiquement vos emplacements publicitaires : ouvrir chaque gabarit sur un téléphone émulé, compter les blocs AdSense, mesurer combien se trouvent au-dessus de la ligne de flottaison, repérer les blocs qui ne réservent aucune hauteur, vérifier ads.txt et enregistrer des captures d’écran de la page entière. Le choix de conception essentiel est de bloquer les domaines publicitaires de Google pendant l’audit : vous contrôlez votre propre balisage sans générer la moindre requête d’annonce.
Que doit vérifier un audit publicitaire automatisé ?
Des contrôles objectifs, entièrement sous votre responsabilité :
| Contrôle | Intérêt |
|---|---|
Nombre de blocs ins.adsbygoogle par gabarit |
détecte les gabarits qui ont doublé des blocs par erreur |
| Blocs dans le premier écran mobile | le contenu doit passer en premier ; voir les règles de placement des annonces |
Blocs de hauteur nulle sans min-height |
source de décalage de mise en page à l’arrivée de l’annonce |
Blocs masqués (display: none) |
masquer des blocs qui diffusent des annonces ne doit pas arriver par accident |
Statut d’ads.txt et ligne google.com ... DIRECT |
un fichier manquant met les revenus en danger |
| Capture de la page entière par gabarit et par appareil | permet à une personne de relire rapidement espacements et libellés |
Ce qu’un audit automatisé juge mal : si un emplacement est « trompeur », si la qualité du contenu est suffisante, ou comment se comporte une enchère. Gardez des relecteurs humains pour ces points.
Pourquoi bloquer les requêtes d’annonces pendant l’audit ?
Chaque chargement de page contenant du code publicitaire actif demande des annonces. Un audit nocturne sur des dizaines d’URL générerait un flux constant de requêtes d’annonces automatisées sur des pages monétisées. Vous n’en avez pas besoin pour vérifier le balisage : bloquez-les. La documentation réseau de Playwright montre comment interrompre les requêtes correspondantes avec page.route() :
await page.route(/googlesyndication\.com|doubleclick\.net|adservice\.google\./, (route) => route.abort());
Effets de bord à prévoir : le script AdSense ne s’exécute pas, donc les annonces automatiques n’insèrent aucun bloc, et aucun attribut data-ad-status n’apparaît. Votre audit voit exactement ce que produisent votre HTML et votre CSS, c’est-à-dire la partie que vous maîtrisez. Pour des tests avec de vraies annonces, lisez d’abord tester ses annonces sans risque.
Le script d’audit
Installez Playwright dans un dossier séparé (version 1.65.1 au moment de la rédaction) ainsi que son build de Chromium :
npm init -y
npm install playwright
npx playwright install chromium
Enregistrez ce code sous le nom audit-ads.mjs :
// audit-ads.mjs: node audit-ads.mjs https://www.example.com/ https://www.example.com/article/
import { chromium, devices } from 'playwright';
import { mkdir } from 'node:fs/promises';
const urls = process.argv.slice(2);
await mkdir('shots', { recursive: true });
const browser = await chromium.launch();
const context = await browser.newContext({ ...devices['iPhone 13'] });
const page = await context.newPage();
// Block Google ad requests: this audit checks your markup and must not request ads.
await page.route(/googlesyndication\.com|doubleclick\.net|adservice\.google\./, (r) => r.abort());
for (const url of urls) {
await page.goto(url, { waitUntil: 'load' });
const viewportHeight = page.viewportSize().height;
const slots = await page.locator('ins.adsbygoogle').evaluateAll((els) =>
els.map((el) => {
const r = el.getBoundingClientRect();
const cs = getComputedStyle(el);
return {
slot: el.dataset.adSlot || null,
format: el.dataset.adFormat || null,
top: Math.round(r.top + scrollY),
height: Math.round(r.height),
minHeight: cs.minHeight,
hidden: cs.display === 'none',
};
})
);
const origin = new URL(url).origin;
const adsTxt = await context.request.get(origin + '/ads.txt');
const adsTxtBody = adsTxt.ok() ? await adsTxt.text() : '';
const report = {
url,
slots: slots.length,
aboveFold: slots.filter((s) => s.top < viewportHeight).length,
noReservedHeight: slots.filter((s) => s.height === 0 && s.minHeight === '0px').length,
adsTxtStatus: adsTxt.status(),
adsTxtHasGoogle: /^\s*google\.com\s*,\s*pub-\d+\s*,\s*DIRECT/im.test(adsTxtBody),
details: slots,
};
console.log(JSON.stringify(report, null, 2));
const name = new URL(url).pathname.replace(/[^a-z0-9]+/gi, '_') || 'home';
await page.screenshot({ path: `shots/${name}.png`, fullPage: true });
}
await browser.close();
Lancez-le avec une URL par gabarit :
node audit-ads.mjs https://www.example.com/ https://www.example.com/some-article/
Ce script a été testé avec Playwright 1.65.1 sur une page de test locale contenant deux blocs publicitaires manuels (l’un avec min-height: 250px, l’autre sans) et un fichier ads.txt d’une ligne. La partie pertinente de la sortie était :
{
"slots": 2,
"aboveFold": 0,
"noReservedHeight": 1,
"adsTxtStatus": 200,
"adsTxtHasGoogle": true
}
C’est le résultat attendu pour cette page de test : le second bloc ne réserve aucun espace et ferait donc descendre le contenu à l’arrivée d’une annonce.
Ajouter un passage sur ordinateur
De nombreux sites modifient la disposition des annonces au-delà d’un point de rupture : des barres latérales apparaissent, les blocs dans le contenu changent de taille, les formats ancrés diffèrent. Exécutez la même boucle dans un second contexte avec une fenêtre de bureau, en utilisant l’option viewport du guide d’émulation :
const desktop = await browser.newContext({ viewport: { width: 1366, height: 768 } });
const desktopPage = await desktop.newPage();
await desktopPage.route(/googlesyndication\.com|doubleclick\.net|adservice\.google\./, (r) => r.abort());
Notez que les routes appartiennent à une page ou à un contexte : le blocage doit donc être redéfini pour le nouveau contexte. Enregistrez les captures dans un dossier différent, ou ajoutez le nom de l’appareil au nom du fichier, pour que les résultats mobile et bureau ne s’écrasent jamais. Comparez le nombre de blocs entre les deux : un gabarit qui affiche quatre blocs sur ordinateur et quatre blocs empilés sur téléphone demande généralement une autre disposition mobile.
Comment fonctionnent les différentes parties
- Émulation d’appareil.
devices['iPhone 13'], tiré du guide d’émulation de Playwright, définit la fenêtre d’affichage, le user agent, le facteur d’échelle et le tactile. Ajoutez un second contexte avec une fenêtre de bureau pour les mises en page larges. - Mesure des blocs.
locator().evaluateAll()s’exécute une seule fois dans la page et renvoie des données simples, ce qui est plus rapide qu’un appel par élément. - ads.txt.
context.request.get()récupère le fichier en dehors de la page, en suivant les redirections. L’expression régulière vérifie seulement qu’une ligne Google DIRECT existe ; pour les règles complètes de syntaxe, voir la syntaxe d’ads.txt. - Captures d’écran.
page.screenshot({ fullPage: true })est l’appel présenté dans le guide des captures de Playwright. Les captures d’élément (locator.screenshot()) servent à saisir la zone autour d’un bloc.
Transformer l’audit en test de non-régression
Une fois la sortie satisfaisante, ajoutez des assertions pour qu’un déploiement échoue lorsqu’une valeur change de façon inattendue :
- Enregistrez les valeurs attendues par gabarit : nombre de blocs,
aboveFoldmaximal,noReservedHeightégal à 0. - Faites échouer le script (
process.exit(1)) quand une valeur diffère. - Exécutez-le en intégration continue sur une version de préproduction, idéalement une version qui n’inclut pas du tout le script publicitaire.
- Conservez les captures comme artefacts de compilation pour qu’un relecteur compare l’avant et l’après.
Le lanceur de tests de Playwright (@playwright/test) propose des comparaisons visuelles avec toHaveScreenshot(), mais les emplacements publicitaires rendent les comparaisons au pixel bruyantes. Comparez des valeurs de mise en page plutôt que des pixels, ou masquez les conteneurs publicitaires.
Comment suivre le statut de remplissage sans robot ?
AdSense ajoute un attribut data-ad-status à chaque élément ins une fois la requête d’annonce terminée, avec des valeurs documentées par Google, par exemple « filled » et « unfilled » (détails dans blocs publicitaires non remplis). Comme l’attribut n’existe qu’après une vraie requête, mesurez-le là où de vraies requêtes ont déjà lieu : sur les pages vues de vos visiteurs.
Cet observateur signale le statut de chaque bloc une fois par page vue vers un point de collecte que vous contrôlez :
const seen = new Set();
const mo = new MutationObserver((records) => {
for (const r of records) {
const el = r.target;
const status = el.getAttribute('data-ad-status');
const key = el.getAttribute('data-ad-slot') || 'auto';
if (!status || seen.has(el)) continue;
seen.add(el);
navigator.sendBeacon('/ad-status', JSON.stringify({ page: location.pathname, slot: key, status }));
}
});
document.querySelectorAll('ins.adsbygoogle').forEach((el) =>
mo.observe(el, { attributes: true, attributeFilter: ['data-ad-status'] }));
Il a été vérifié dans Playwright sur une page locale où un script définissait l’attribut : il a envoyé une balise par bloc avec le statut attendu. Il ne surveille que les blocs présents au moment de son exécution ; les blocs d’annonces automatiques insérés plus tard demandent un observateur supplémentaire sur le document avec childList: true, subtree: true. Agrégez les résultats par bloc et par gabarit de page pour repérer les blocs qui se remplissent rarement, et comparez avec vos rapports AdSense avant de supprimer quoi que ce soit. Google précise aussi que l’attribut n’est pas ajouté pour les blocs diffusés via une fenêtre inter-domaines.
Erreurs fréquentes
- Laisser les annonces activées dans les audits nocturnes. Bloquez les domaines publicitaires ou auditez une version sans code publicitaire.
- Scripter des clics à proximité des annonces. Même des clics « de test » constituent une activité non valide.
- N’auditer que la page d’accueil. Les gabarits d’articles et de catégories portent généralement la plupart des blocs.
- Tester uniquement sur ordinateur. La plupart des problèmes de mise en page publicitaire apparaissent aux largeurs de téléphone.
- Se fier à
waitUntil: 'networkidle'sur des pages chargées de publicité. Ces pages deviennent rarement inactives ; utilisezloadplus des attentes explicites sur vos propres éléments.
Associez cet audit à Lighthouse CI pour les budgets de performance, et à des données d’utilisateurs réels pour ce que vivent réellement les visiteurs.
Outils open source cités
| Outil | Licence |
|---|---|
| Playwright | Apache-2.0 |
Questions fréquentes
Peut-on lancer Playwright sans risque sur des pages qui affichent mes annonces AdSense ?
Oui, à condition que le script bloque les domaines publicitaires de Google avec page.route(), car aucune requête d'annonce ne quitte alors le navigateur. Lancer des navigateurs automatisés avec les annonces activées génère des requêtes d'annonces émises par un robot, ce qu'il faut éviter sur des pages monétisées. Ne scriptez jamais de clics sur des annonces et réservez toute vérification avec annonces à de rares sessions manuelles dans un navigateur ordinaire.
Pourquoi mon audit ne trouve-t-il aucun bloc sur des pages en annonces automatiques ?
Les annonces automatiques placent leurs blocs avec du JavaScript une fois le script AdSense chargé. Si l'audit bloque les requêtes d'annonces, le script ne s'exécute jamais et aucun bloc d'annonces automatiques n'est inséré : seuls les blocs ins.adsbygoogle manuels présents dans votre HTML sont comptés. Pour auditer la mise en page des annonces automatiques, appuyez-vous sur les outils d'aperçu d'AdSense et sur des données d'utilisateurs réels plutôt que sur un navigateur automatisé.
Playwright peut-il vérifier si mes emplacements sont remplis ?
Seulement en laissant les annonces se charger, puisqu'AdSense définit data-ad-status sur l'élément ins une fois la requête d'annonce terminée. Cela suppose des requêtes d'annonces automatisées. Une méthode plus sûre consiste à placer sur vos pages en production un petit MutationObserver qui envoie le data-ad-status de chaque bloc, observé chez de vrais visiteurs, vers votre propre point de collecte, comme le montre ce guide.
Quel appareil émuler pour les audits publicitaires ?
Utilisez au moins un profil de téléphone et un profil de bureau. Playwright fournit des descripteurs d'appareils comme devices['iPhone 13'], qui définissent fenêtre d'affichage, user agent, facteur d'échelle et tactile. La plupart des problèmes de mise en page liés aux annonces (blocs placés avant le contenu, unités empilées, hauteur non réservée) apparaissent d'abord sur les écrans étroits.
Sources
- Network | Playwright · Playwright
- Screenshots | Playwright · Playwright
- Emulation | Playwright · Playwright
Guides liés
- Emplacements publicitaires AdSense vides : lire data-ad-status et traiter proprement les espaces blancs
Pourquoi des emplacements AdSense restent vides, ce que signalent filled, unfilled et unfill-optimized dans data-ad-status, et comment les masquer ou les remplacer.
- Règles d'emplacement des annonces AdSense : libellés, clics accidentels, navigation, pop-ups et annonces flottantes
Règles d'emplacement des annonces AdSense : libellés autorisés, incitation aux clics, annonces près de la navigation, pop-ups, actualisation, corrections.
- Cliquer sur ses propres annonces AdSense : pourquoi c'est interdit et comment tester les annonces sans risque
Cliquer sur ses propres annonces AdSense est interdit, quelle qu'en soit la raison. Comment tester sans cliquer et que faire après une erreur.
- Lighthouse et Lighthouse CI sur des pages chargées de publicité : configuration, budgets et mesure de l'impact des tiers
Lancez Lighthouse et Lighthouse CI sur des pages AdSense : configuration testée, budgets pour les scripts tiers, comparaison avec et sans annonces.