Code et intégration

Comment ajouter Google AdSense à un site Next.js avec l'App Router

Mis à jour le Publié le Par la rédaction7 min5 sources

L'essentiel

  • Dans l'App Router de Next.js, une balise next/script placée dans la mise en page racine charge la bibliothèque AdSense une seule fois pour toutes les routes, et Next.js garantit qu'elle ne se charge qu'une fois au fil des navigations.
  • La stratégie par défaut afterInteractive injecte le script côté client après une partie de l'hydratation, tandis que beforeInteractive l'injecte dans le head du HTML initial.
  • Les unités publicitaires demandent un composant client qui affiche l'élément ins et appelle adsbygoogle.push dans useEffect, car le push touche à window.
  • Next.js transmet les attributs supplémentaires, comme nonce et crossOrigin, du composant Script à l'élément script final.
  • Les fichiers statiques du dossier public, comme public/ads.txt, sont servis à la racine du site.
Fenêtre du navigateur Firefox affichant une page de Wikipédia
Image: Firefox web browser on wikipedia page,Mozilla Corporation,CC BY-SA 4.0,via Wikimedia Commons.

Dans un projet Next.js avec l’App Router, chargez le code AdSense une seule fois depuis la mise en page racine avec next/script, affichez chaque unité publicitaire depuis un petit composant client qui appelle adsbygoogle.push dans useEffect, et placez ads.txt dans public/. Le point que la plupart des tutoriels oublient est la navigation : les mises en page persistent d’une route à l’autre, et un emplacement situé dans une mise en page a donc besoin d’un nouvel élément <ins> à chaque route avant de pouvoir demander une nouvelle annonce.

Qu’est-ce qui change par rapport à un site HTML classique ?

Les instructions de Google sont écrites pour du HTML statique : le code AdSense va dans le <head>, le code de l’unité publicitaire va dans le <body>, là où l’annonce doit apparaître (Where to place ad unit code in your HTML). Avec l’App Router, trois différences sont à gérer :

  1. Les balises <script> en ligne dans les composants React ne sont pas exécutées comme dans du HTML brut : l’appel de push propre à chaque unité doit donc passer dans du JavaScript exécuté après le rendu.
  2. La navigation côté client ne recharge pas le document. La bibliothèque reste chargée, les mises en page restent montées et seuls les segments modifiés sont rendus de nouveau.
  3. Les Server Components ne peuvent pas toucher à window : le push doit donc se trouver dans un Client Component ('use client').

Le code ci-dessous cible l’App Router actuel (Next.js 16 au moment de la rédaction). Il utilise ca-pub-0000000000000000 et l’emplacement 1234567890 comme valeurs fictives.

Comment charger le script AdSense dans la mise en page racine ?

Le guide des scripts de Next.js montre des scripts tiers placés dans la mise en page racine pour se charger sur toutes les routes, et précise que Next.js garantit que le script ne se charge qu’une fois, même si l’utilisateur navigue entre plusieurs pages (« Next.js will ensure the script will only load once, even if a user navigates between multiple pages »).

// app/layout.tsx
import Script from 'next/script'

const adsEnabled = process.env.NODE_ENV === 'production'

export default function RootLayout({
  children,
}: {
  children: React.ReactNode
}) {
  return (
    <html lang="en">
      <body>{children}</body>
      {adsEnabled && (
        <Script
          async
          src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-0000000000000000"
          crossOrigin="anonymous"
          strategy="afterInteractive"
        />
      )}
    </html>
  )
}

Next.js transmet à l’élément <script> final les attributs qu’il n’utilise pas lui-même (comme crossOrigin ou nonce), comme l’explique le guide des scripts dans sa section « Additional Attributes ».

Quelle stratégie convient à AdSense ?

Stratégie Ce que dit la référence de Script Adéquation avec AdSense
beforeInteractive Injecté dans le head du HTML initial, téléchargé avant le code Next.js ; doit figurer dans la mise en page racine ; pour les scripts critiques Fonctionne, mais se dispute la bande passante précoce avec votre propre code
afterInteractive (par défaut) Injecté côté client, chargé après une partie de l’hydratation ; suggéré pour les gestionnaires de balises et l’analyse d’audience Bon choix par défaut
lazyOnload Injecté pendant un temps d’inactivité du navigateur, une fois toutes les ressources récupérées Retarde chaque requête publicitaire ; les annonces en haut de page apparaissent tardivement
worker Expérimental, ne fonctionne pas encore avec l’App Router (« does not yet work with the App Router ») À ne pas utiliser

Une conséquence d’afterInteractive : le script ne figure pas dans le HTML rendu côté serveur. Si vous prévoyez de connecter votre site à AdSense avec la méthode de l’extrait de code, le robot de vérification risque de ne pas le voir. Utilisez plutôt la méthode ads.txt ou la balise meta, décrites dans connecter un site à AdSense, ou passez à beforeInteractive.

Vous pouvez aussi voir cet avertissement dans la console : “AdSense head tag doesn’t support data-nscript attribute.” next/script ajoute data-nscript à la balise, et la bibliothèque AdSense signale par un avertissement les attributs data qu’elle ne reconnaît pas sur sa balise du head. Ce n’est qu’un avertissement.

Comment construire un composant client d’unité publicitaire ?

// app/components/AdUnit.tsx
'use client'

import { useEffect, useRef } from 'react'
import { usePathname } from 'next/navigation'

declare global {
  interface Window {
    adsbygoogle: unknown[]
  }
}

type Props = { adSlot: string; minHeight?: number }

export default function AdUnit({ adSlot, minHeight = 280 }: Props) {
  const pathname = usePathname()
  const pushedFor = useRef<string | null>(null)

  useEffect(() => {
    if (pushedFor.current === pathname) return
    pushedFor.current = pathname
    try {
      ;(window.adsbygoogle = window.adsbygoogle || []).push({})
    } catch (err) {
      console.error(err)
    }
  }, [pathname])

  return (
    <div style={{ minHeight }}>
      <ins
        key={pathname}
        className="adsbygoogle"
        style={{ display: 'block' }}
        data-ad-client="ca-pub-0000000000000000"
        data-ad-slot={adSlot}
        data-ad-format="auto"
        data-full-width-responsive="true"
      />
    </div>
  )
}

Fonctionnement :

  • usePathname renvoie le chemin courant (référence de usePathname), et la documentation le montre utilisé avec useEffect pour réagir à un changement de route.
  • key={pathname} fait remplacer l’<ins> par un élément neuf par React à chaque changement de route. Un <ins> déjà rempli ne peut pas l’être de nouveau ; la bibliothèque consigne « All ‘ins’ elements in the DOM with class=adsbygoogle already have ads in them. » si vous faites un push sans nouvel emplacement vide.
  • La ref pushedFor empêche un second push pour la même route. C’est important en développement, où le mode strict de React exécute les effets deux fois.
  • Le minHeight du conteneur réserve de l’espace pour que l’annonce ne décale pas le contenu. Ajustez-le à votre mise en page ; voyez la réservation d’espace pour les annonces.
  • Dans une page (et non une mise en page), le composant est de toute façon démonté puis remonté à la navigation ; c’est la clé qui le fait fonctionner dans des mises en page persistantes, comme une barre latérale.

Utilisation depuis n’importe quel Server Component :

// app/blog/[slug]/page.tsx
import AdUnit from '@/app/components/AdUnit'

export default async function Post() {
  return (
    <article>
      <h1>Post title</h1>
      <p>Intro...</p>
      <AdUnit adSlot="1234567890" />
      <p>Body...</p>
    </article>
  )
}

Demander une nouvelle annonce après qu’un utilisateur a navigué vers un nouveau contenu n’est pas la même chose que l’actualisation périodique des annonces. Les règles de placement des annonces interdisent d’actualiser une page ou un élément de page sans que l’utilisateur ait demandé l’actualisation : ne relancez donc jamais un push sur un intervalle, au défilement ou au retour de focus sur l’onglet.

Qu’en est-il des annonces automatiques dans une application Next.js ?

Avec le script de la mise en page racine en place, activer les annonces automatiques dans AdSense suffit pour la première page vue. Google ne documente pas le comportement des annonces automatiques lors des changements de route côté client dans un routeur de framework : ne supposez donc pas qu’elles réanalysent chaque route. Le guide sur les applications monopage discute les options, dont le chargement de page complet pour certains liens. Dans Next.js, un élément <a> ordinaire à la place de <Link> provoque un chargement de page complet pour ce lien.

Comment ajouter un nonce CSP ?

Si votre site utilise une Content Security Policy à nonce, Next.js documente la génération d’un nonce neuf à chaque requête dans proxy.ts, son passage par un en-tête de requête x-nonce et sa lecture dans un Server Component (guide CSP de Next.js) :

// app/layout.tsx (excerpt)
import { headers } from 'next/headers'
import Script from 'next/script'

export default async function RootLayout({ children }: { children: React.ReactNode }) {
  const nonce = (await headers()).get('x-nonce') ?? undefined
  return (
    <html lang="en">
      <body>{children}</body>
      <Script
        async
        src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-0000000000000000"
        crossOrigin="anonymous"
        nonce={nonce}
      />
    </html>
  )
}

La documentation de Next.js avertit que les nonces exigent un rendu dynamique : les pages statiques sont générées au moment du build, quand aucune requête n’existe pour créer un nonce. Les directives dont le code AdSense a lui-même besoin sont traitées dans CSP pour AdSense.

Où placer ads.txt ?

Créez public/ads.txt. Next.js sert les fichiers de public depuis l’URL racine : le fichier est donc disponible à l’adresse /ads.txt :

google.com, pub-0000000000000000, DIRECT, f08c47fec0942fa0

Vérifiez-le sur le domaine de production après le déploiement. Un matcher de proxy.ts ou une réécriture qui capte tous les chemins peut l’intercepter par erreur.

Dépannage

Symptôme Cause Correctif
“adsbygoogle.push() error: All ‘ins’ elements … already have ads in them.” Plus de push que d’emplacements vides (double effet du mode strict, composants en double) Protéger avec une ref, un seul push par nouvel <ins>
Annonce vide après navigation, les autres pages sont correctes L’emplacement d’une mise en page persistante garde son <ins> déjà rempli Ajouter key={pathname} à l’<ins>
“No slot size for availableWidth=0” Le conteneur n’avait aucune largeur au moment du push (onglet masqué, accordéon replié, display:none) Ne faire le push que lorsque l’emplacement est visible et mis en page
Annonces en développement Pas de protection par l’environnement Vérifier NODE_ENV ou votre propre indicateur avant l’affichage

Conservez le code publicitaire tel que Google le fournit : même URL de script, mêmes attributs <ins>, même appel de push. La règle de modification du code AdSense autorise les changements pour une expérience utilisateur propre et le dimensionnement responsive, pas ceux qui modifient la manière dont les annonces sont diffusées.

Questions fréquentes

Quelle stratégie next/script utiliser pour AdSense ?

La stratégie par défaut, afterInteractive, est un choix raisonnable : Next.js la décrit comme un chargement précoce mais après une partie de l'hydratation, ce qui convient aux gestionnaires de balises et à l'analyse d'audience. beforeInteractive place le script dans le head du HTML initial, mais vise les scripts critiques comme les gestionnaires de consentement. lazyOnload attend un temps d'inactivité du navigateur et retarde chaque requête publicitaire. La stratégie worker est expérimentale et ne fonctionne pas avec l'App Router.

Pourquoi vois-je "AdSense head tag doesn't support data-nscript attribute" dans la console ?

next/script ajoute un attribut data-nscript au script qu'il produit. La bibliothèque AdSense lit les attributs data- de sa balise du head comme des réglages, en trouve un qu'elle ne connaît pas et affiche un avertissement. C'est un avertissement de console, pas une erreur, et les annonces se chargent quand même. Pour une console propre, affichez plutôt une balise script ordinaire dans le head de la mise en page racine.

Pourquoi mon annonce reste-t-elle vide après une navigation côté client dans Next.js ?

Si le composant publicitaire se trouve dans une mise en page qui persiste d'une route à l'autre, le même élément ins reste dans le DOM et il est déjà rempli : aucune nouvelle requête n'est donc faite. Donnez à l'ins une clé fondée sur usePathname pour que React crée un nouvel élément à la navigation, puis lancez un seul push pour ce nouvel élément dans useEffect.

Peut-on utiliser AdSense sur des pages Next.js exportées statiquement ?

Oui. Le code publicitaire s'exécute dans le navigateur, l'export statique fonctionne donc. L'exception concerne une Content Security Policy avec nonces : Next.js n'injecte les nonces que sur des pages rendues dynamiquement, car une page statique n'a pas de requête à partir de laquelle générer un nonce.

Sources

  1. Script Component · Next.js Docs
  2. How to load and optimize scripts · Next.js Docs
  3. usePathname · Next.js Docs
  4. How to set a Content Security Policy (CSP) for your Next.js application · Next.js Docs
  5. Where to place ad unit code in your HTML · Google AdSense Help