SemSpider : chaque page passée au crible

Fuite Google Content Warehouse attributs : siteFocusScore siteRadius

#1 google, python, script, liens, trafic

JaffaarGuardian
8 744 messages1 434 j'aimedepuis 2012Consultant SEO / WEB / IA
Site Web
Distinctions · 22
Pilier VIIIPhilanthrope VIIPremier secours VIIAccueillant VI12 ansAdministrateurKilluavieConsommateur de liensÉminentClinicien VExpert SEO VForce polyvalenteExpert IA et GEO IVExpert Outils et technique IIIStratège IIAutomate IISérie IIRéactionsExpert Multi-canalExpert BusinessIngénieur webBusiness man

Fuite Google Content Warehouse attributs : siteFocusScore siteRadius

17 min de lecture 4 parties

Salut à tous,

Dans la fuite de la doc interne de Google (Content Warehouse, 2024), deux attributs sont passés inaperçus : siteFocusScore et siteRadius. Google transforme vos pages en vecteurs, calcule le centre thématique du site, et mesure à quel point chaque page s'en éloigne.

En brefles pages loin du cœur de votre site diluent votre autorité thématique. Script ci-dessous : vous donnez l'URL, il calcule tout, gratuitement et en local.

j'ai concocté un petit script py pour reproduire cette modélisation en local afin d'analyser nos sites (en partie) comme google (sur ces 2 angles siteFocusScore et siteRadius dans ce cas)

:chart: Lancement

pip install requests sentence-transformers
python semfocus.py https://votre-site.fr

Python 3.9 minimum. Le modèle transformers (1go) se télécharge au premier lancement, ca prend un peu de temps ensuite tout tourne hors ligne.

HXW6BrsXMAAAZrp?format=jpg&name=large

:chart:  Pour ceux qui veulent générer des visualisation du même genre voici le github directement : https://github.com/jaffaars/semfocus

Tutoriel plus bas pour ceux qui veulent le scripts directement à copier coller + marche à suivre.

Il lit le sitemap (ou suit les liens internes), garde le contenu principal sans menus ni footer, et sort : le cœur du site, les 10 % de pages les plus éloignées, les paires de pages trop proches, un CSV pour Excel et une carte des pages (SVG à ouvrir dans le navigateur, survolez un point pour voir la page).

:bulb: Ce qu'on en fait

  • Loin du centre, sans trafic : suppression, économie de liens internes ou noindex.

  • Loin du centre, avec du trafic : on la rattache au cœur par le maillage et recontextualisation logique

  • Proche du centre mais mal positionnée : Page à renforcer en sémantique et maillage.

  • Quasi-doublons : fusion + 301, ou bien différencier vraiment les deux pages.

Une nuance importante : la fuite donne le nom des attributs, pas leur poids. C'est un diagnostic, pas une formule magique, et les scores ne se comparent qu'entre pages d'un même site.

:check:  Lancement pas à pas

  1. Installer Python (3.9 minimum) depuis python.org/downloads. Sous Windows, cochez Add python.exe to PATH pendant l'installation.

  2. Copier le script en bas de ce post dans un fichier semfocus.py : Bloc-notes → Enregistrer sous → Type « Tous les fichiers », par exemple dans un dossier Documents\semfocus.

  3. Ouvrir un terminal dans ce dossier : sous Windows, clic droit dans le dossier → Ouvrir dans le Terminal. Sur Mac, ouvrez Terminal, tapez cd + espace et glissez le dossier dans la fenêtre.

  4. Installer les dépendances (une seule fois) :

    pip install requests sentence-transformers
  5. Lancer l'analyse :

    python semfocus.py https://votre-site.fr

    Sur Mac : pip3 et python3 à la place.

  6. Lire le résultat dans le terminal, puis ouvrir semfocus-votre-site.fr.csv et la carte semfocus-votre-site.fr.svg, créés dans le même dossier.


Le script (semfocus.py)

#!/usr/bin/env python3
"""semfocus : mesure le focus sémantique d'un site (idée de siteFocusScore / siteRadius).

Installation : pip install requests sentence-transformers
Usage        : python semfocus.py https://exemple.fr
Options      : --max 300 (pages analysées)
               --model intfloat/multilingual-e5-base (plus précis, plus lent)
"""
import argparse, csv, gzip, html, os, re, sys, time
from collections import Counter
from concurrent.futures import ThreadPoolExecutor
from html.parser import HTMLParser
from urllib.parse import urljoin, urlparse, urldefrag
import xml.etree.ElementTree as ET

import numpy as np
import requests

SKIP_EXT = re.compile(r"\.(jpe?g|png|gif|webp|avif|svg|pdf|zip|rar|mp4|mp3|css|js|json|xml|txt|ico|woff2?)$", re.I)
SKIP_TAGS = {"script", "style", "noscript", "svg", "nav", "header", "footer", "aside", "form", "iframe", "template", "button", "select"}
BLOCKS = {"p", "li", "h1", "h2", "h3", "h4", "h5", "h6", "td", "th", "blockquote", "pre", "div", "section", "dd", "dt", "figcaption", "br"}
MAIN = ("main", "article")
os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS_WARNING", "1")  # avertissement sans conséquence sous Windows
os.environ.setdefault("HF_HUB_VERBOSITY", "error")

http = requests.Session()
http.headers["User-Agent"] = "Mozilla/5.0 (compatible; semfocus/1.0)"
failures = Counter()  # pages non récupérées, par motif


def get(url):
    """GET poli : patiente et réessaie si le site limite le débit (429, 503)."""
    for attempt in range(4):
        try:
            r = http.get(url, timeout=15)
        except requests.RequestException:
            failures["réseau"] += 1
            return None
        if r.status_code in (429, 503) and attempt < 3:
            wait = r.headers.get("Retry-After", "")
            time.sleep(min(int(wait), 60) if wait.isdigit() else 10 * (attempt + 1))
            continue
        if r.status_code != 200:
            failures[f"HTTP {r.status_code}"] += 1
            return None
        return r
    return None


def host(url):
    return urlparse(url).netloc.lower().removeprefix("www.")


def clean(url):
    return urldefrag(url)[0].rstrip("/")


class Page(HTMLParser):
    """Texte par blocs, sans menus, en-têtes, pieds de page ni scripts ; <main> ou <article> en priorité.
    Les blocs faits surtout de liens (listes de sujets, nuages de tags, fils d'Ariane) sont écartés."""

    def __init__(self):
        super().__init__(convert_charrefs=True)
        self.skip = self.main = self.link = 0
        self.buf, self.blocks, self.main_blocks, self.links = [], [], [], []
        self.title, self.in_title, self.noindex, self.lang = "", False, False, ""

    def flush(self):
        text = " ".join("".join(t for t, _ in self.buf).split())
        linked = len("".join(t for t, in_link in self.buf if in_link).strip())
        if text and linked <= 0.5 * len(text):
            self.blocks.append(text)
            if self.main:
                self.main_blocks.append(text)
        self.buf = []

    def handle_starttag(self, tag, attrs):
        a = dict(attrs)
        if tag == "html":
            self.lang = (a.get("lang") or "")[:2].lower()
        if tag == "a" and a.get("href"):
            self.links.append(a["href"])
        if tag == "meta" and (a.get("name") or "").lower() == "robots" and "noindex" in (a.get("content") or "").lower():
            self.noindex = True
        if tag in BLOCKS or tag in SKIP_TAGS or tag in MAIN:
            self.flush()
        self.in_title |= tag == "title"
        self.skip += tag in SKIP_TAGS
        self.main += tag in MAIN
        self.link += tag == "a"

    def handle_endtag(self, tag):
        if tag in BLOCKS or tag in SKIP_TAGS or tag in MAIN:
            self.flush()
        if tag == "title":
            self.in_title = False
        if tag == "a" and self.link:
            self.link -= 1
        if tag in SKIP_TAGS and self.skip:
            self.skip -= 1
        if tag in MAIN and self.main:
            self.main -= 1

    def handle_data(self, data):
        if self.in_title:
            self.title += data
        elif not self.skip:
            self.buf.append((data, self.link > 0))


def fetch(url):
    r = get(url)
    if not r or "html" not in r.headers.get("Content-Type", ""):
        return None
    p = Page()
    p.feed(r.text)
    p.flush()
    blocks = p.main_blocks if sum(len(b.split()) for b in p.main_blocks) >= 80 else p.blocks
    links = [clean(urljoin(r.url, l)) for l in p.links]
    return {"url": clean(r.url), "title": " ".join(p.title.split()), "blocks": blocks, "links": links, "noindex": p.noindex, "lang": p.lang}


def sitemap_urls(root):
    robots = get(urljoin(root, "/robots.txt"))
    queue = re.findall(r"(?im)^\s*sitemap:\s*(\S+)", robots.text) if robots else []
    queue = queue or [urljoin(root, "/sitemap.xml"), urljoin(root, "/sitemap_index.xml")]
    seen, pages = set(), []
    while queue and len(seen) < 100:
        url = queue.pop(0)
        if url in seen:
            continue
        seen.add(url)
        r = get(url)
        if not r:
            continue
        data = gzip.decompress(r.content) if r.content[:2] == b"\x1f\x8b" else r.content
        try:
            tree = ET.fromstring(data)
        except ET.ParseError:
            continue
        index = tree.tag.endswith("sitemapindex")
        for entry in tree:
            for child in entry:
                if child.tag.split("}")[-1] == "loc" and child.text:
                    (queue if index else pages).append(child.text.strip())
    return list(dict.fromkeys(pages))


def collect(root, limit):
    site = host(root)
    urls = [u for u in sitemap_urls(root) if host(u) == site and not SKIP_EXT.search(urlparse(u).path)]
    pages, seen = [], set()
    with ThreadPoolExecutor(4) as pool:
        if urls:
            print(f"Sitemap : {len(urls)} adresses", end="")
            if len(urls) > limit:  # échantillon réparti sur tout le sitemap
                urls = [urls[int(i * len(urls) / limit)] for i in range(limit)]
                print(f", échantillon de {limit}", end="")
            print()
            pages = [p for p in pool.map(fetch, urls) if p]
        else:
            print("Pas de sitemap : exploration des liens internes")
            todo = [clean(root)]
            seen.add(todo[0])
            while todo and len(pages) < limit:
                batch, todo = todo[:16], todo[16:]
                for p in pool.map(fetch, batch):
                    if not p or len(pages) >= limit:
                        continue
                    pages.append(p)
                    for l in p["links"]:
                        if host(l) == site and l not in seen and not SKIP_EXT.search(urlparse(l).path):
                            seen.add(l)
                            todo.append(l)
    if failures:
        print("Pages non récupérées : " + ", ".join(f"{n} ({k})" for k, n in failures.items()))
    unique = {}
    for p in pages:
        if not p["noindex"]:
            unique.setdefault(p["url"], p)
    return list(unique.values())


def strip_boilerplate(pages):
    """Retire les blocs répétés sur plus de 30 % des pages (menus, encarts, mentions)
    et les fragments de moins de 5 mots (dates, compteurs, boutons, pseudos)."""
    for p in pages:
        p["blocks"] = [b for b in p["blocks"] if len(b.split()) >= 5]
    count = {}
    for p in pages:
        for b in set(p["blocks"]):
            count[b] = count.get(b, 0) + 1
    limit = max(2, 0.3 * len(pages))
    for p in pages:
        p["text"] = " ".join(b for b in p["blocks"] if count[b] <= limit)


def short(url, root):
    u = urlparse(url)
    return (u.path or "/") + ("?" + u.query if u.query else "")


def write_svg(path, C, verdicts, pages, focus, root):
    """Carte radiale : distance au centre = 1 - focus (mise à l'échelle), angle = ACP des vecteurs centrés (approximatif).
    Le cercle est le rayon moyen du site, et les pages loin du centre sont dehors."""
    _, _, vt = np.linalg.svd(C, full_matrices=False)
    ang = np.arctan2(C @ vt[1], C @ vt[0])
    dist = 1 - focus
    dist = (dist - dist.min()) / max(np.ptp(dist), 1e-9)  # mise à l'échelle : de la page la plus centrale à la plus éloignée
    w, h, m = 900, 700, 60
    k = min((w - 2 * m) / 2, (h - 2 * m - 60) / 2)
    cx, cy = w / 2, (h - 60) / 2 + 10
    xy = np.c_[np.cos(ang) * dist, np.sin(ang) * dist]
    r = dist.mean() * k
    colors = {"cœur": "#ECC46A", "à surveiller": "#8E959F", "loin du centre": "#F0645A"}
    out = [f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {w} {h}" font-family="Segoe UI, Arial, sans-serif">',
           f'<rect width="{w}" height="{h}" fill="#18191C"/>',
           f'<text x="24" y="34" fill="#CDD1D6" font-size="16">semfocus · {html.escape(host(root))} · {len(pages)} pages (survolez un point)</text>',
           f'<circle cx="{cx}" cy="{cy}" r="{r:.1f}" fill="#DCAB4C" fill-opacity=".07" stroke="#DCAB4C" stroke-dasharray="6 5"/>']
    for i in np.argsort(-focus):  # les pages éloignées sont dessinées en dernier, au-dessus
        tip = html.escape(f"{pages[i]['title']}\n{pages[i]['url']}\nfocus {focus[i]:.3f} · {verdicts[i]}")
        out.append(f'<circle cx="{cx + xy[i, 0] * k:.1f}" cy="{cy - xy[i, 1] * k:.1f}" r="5" fill="{colors[verdicts[i]]}"><title>{tip}</title></circle>')
    out.append(f'<path d="M{cx - 9} {cy}h18M{cx} {cy - 9}v18" stroke="#F2F3F5" stroke-width="2"/>')
    y, x = h - 26, 24
    for label, col in colors.items():
        out.append(f'<circle cx="{x + 6}" cy="{y - 5}" r="6" fill="{col}"/><text x="{x + 18}" y="{y}" fill="#CDD1D6" font-size="14">{label}</text>')
        x += 140
    out.append(f'<text x="{x}" y="{y}" fill="#A3A9B2" font-size="13">+ centre · cercle = rayon moyen · distance à l’échelle, angle approximatif</text></svg>')
    with open(path, "w", encoding="utf-8") as f:
        f.write("\n".join(out))


def main():
    if hasattr(sys.stdout, "reconfigure"):
        sys.stdout.reconfigure(encoding="utf-8")
    ap = argparse.ArgumentParser(description="Focus sémantique d'un site")
    ap.add_argument("url")
    ap.add_argument("--max", type=int, default=300)
    ap.add_argument("--model", default="intfloat/multilingual-e5-small")
    args = ap.parse_args()
    root = args.url if "://" in args.url else "https://" + args.url

    pages = collect(root, args.max)
    strip_boilerplate(pages)
    pages = [p for p in pages if len(p["text"].split()) >= 50]
    if len(pages) < 5:
        sys.exit(f"Seulement {len(pages)} pages avec assez de texte : impossible de calculer un centre.")
    print(f"{len(pages)} pages indexables d'au moins 50 mots\n")

    from sentence_transformers import SentenceTransformer
    model = SentenceTransformer(args.model)
    e5 = "e5" in args.model
    docs = [("passage: " if e5 else "") + (p["title"] + ". " + p["text"])[:3000] for p in pages]
    E = model.encode(docs, normalize_embeddings=True, batch_size=16, show_progress_bar=True)

    # Un centre par langue (5 pages au moins) : une page traduite se compare aux pages de sa langue
    langs = np.array([p["lang"] for p in pages])
    counts = Counter(langs)
    if len(counts) > 1:
        print("Langues : " + ", ".join(f"{l or '?'} {n}" for l, n in counts.most_common()))
    groups = [np.where(langs == l)[0] for l, n in counts.items() if n >= 5]
    rest = np.where([counts[l] < 5 for l in langs])[0]
    focus, C = np.zeros(len(pages)), np.zeros_like(E)
    for g in groups + ([rest] if len(rest) else []):
        mean = E[g].mean(0) if len(g) >= 5 else E.mean(0)
        focus[g] = E[g] @ (mean / np.linalg.norm(mean))
        C[g] = E[g] - mean
    p10, p25 = np.percentile(focus, [10, 25])
    # Proximité entre pages sur les vecteurs centrés : sans le "fond commun" du site, les écarts redeviennent lisibles
    Cn = C / np.linalg.norm(C, axis=1, keepdims=True)
    S = Cn @ Cn.T
    np.fill_diagonal(S, -1)
    S[langs[:, None] != langs[None, :]] = -1  # une page et sa traduction se ressemblent forcément
    near = S.argmax(1)
    order = np.argsort(focus)

    print(f"\nFocus médian : {np.median(focus):.3f}   rayon moyen (1 - focus) : {np.mean(1 - focus):.3f}")
    print("Les valeurs dépendent du modèle : comparez les pages entre elles, pas à un seuil absolu.\n")
    print("== Cœur du site (les plus proches du centre) ==")
    for i in order[::-1][:5]:
        print(f"  {focus[i]:.3f}  {short(pages[i]['url'], root)}  {pages[i]['title'][:60]}")
    print("\n== Loin du centre (10 % les plus bas) : supprimer, rattacher ou sortir du site ==")
    for i in order[: max(3, len(pages) // 10)]:
        print(f"  {focus[i]:.3f}  {short(pages[i]['url'], root)}  {pages[i]['title'][:60]}")

    iu = np.triu_indices(len(pages), 1)
    pairs = S[iu]
    print("\n== Paires les plus proches : doublons ou cannibalisation à vérifier ==")
    for k in np.argsort(pairs)[::-1][:10]:
        i, j = iu[0][k], iu[1][k]
        print(f"  {pairs[k]:.3f}  {short(pages[i]['url'], root)}  <->  {short(pages[j]['url'], root)}")

    verdicts = ["loin du centre" if f <= p10 else "à surveiller" if f <= p25 else "cœur" for f in focus]
    out = f"semfocus-{host(root)}.csv"
    with open(out, "w", newline="", encoding="utf-8-sig") as f:
        w = csv.writer(f, delimiter=";")
        w.writerow(["url", "titre", "focus", "verdict", "page la plus proche", "similarité"])
        for i in order:
            w.writerow([pages[i]["url"], pages[i]["title"], f"{focus[i]:.4f}", verdicts[i], pages[near[i]]["url"], f"{S[i, near[i]]:.4f}"])
    write_svg(f"semfocus-{host(root)}.svg", C, verdicts, pages, focus, root)
    print(f"\nTableau complet : {out}")
    print(f"Carte des pages : semfocus-{host(root)}.svg (à ouvrir dans le navigateur)")


if __name__ == "__main__":
    main()
 


⌁ NET-LABS — SEO INTELLIGENCE.
    Discord • SemSeeker • SemSpider

🔥 2
1
J'aime ❤️

En ligne

7 référents en Sémantique répondent dans cet espaceInscription gratuite : présentez-vous, puis posez vos questions et répondez aux discussions.

#2 script, maillage, sémantique, contenu

StoneScout
144 messages30 j'aimedepuis 2016Montpellier
Distinctions · 8
10 ansPilier IIIStratège IIAppréciéPhilanthrope IIClinicien IIAccueillant IIExpert SEO

Re : Fuite Google Content Warehouse attributs : siteFocusScore siteRadius

Salut Jaffaar et merci pour le script.

Je l'ai installé, je ne sais pas si dans tes exemples tu as eu le même cas, mais au centre je m'attendais à avoir la home, alors qu'elle arrive chez moi en 17e position (coeur) : pourquoi ?
Ce n'est pas censé être la page qui a le plus de poids / force ?

Pour les pages qui ont les meilleurs scores (focus et verdict) : qu'est-ce qu'il faut en déduire ?
Elles ont un meilleur maillage ? Une meilleure thématisation sémantique ? On peut s'appuyer sur elle pour mailler les pages les plus éloignées du centre ?

J'ai des pages "produits" qui sont perdues dans l’arborescence, très peu maillées, contenu moyen et pourtant elles ont un gros score.

💡 1
1
J'aime ❤️

Hors ligne

#3 lien, maillage, script, sémantique, contenu

JaffaarGuardianAuteur
8 744 messages1 434 j'aimedepuis 2012Consultant SEO / WEB / IA
Site Web
Distinctions · 22
Pilier VIIIPhilanthrope VIIPremier secours VIIAccueillant VI12 ansAdministrateurKilluavieConsommateur de liensÉminentClinicien VExpert SEO VForce polyvalenteExpert IA et GEO IVExpert Outils et technique IIIStratège IIAutomate IISérie IIRéactionsExpert Multi-canalExpert BusinessIngénieur webBusiness man

Re : Fuite Google Content Warehouse attributs : siteFocusScore siteRadius

@Stone cool pour le retour !

Pour te répondre : le score ne mesure ni la force ni le maillage : le script ne lit aucun lien.
Il compare seulement le texte de chaque page au "centre thématique" du site, c'est-à-dire la moyenne de toutes les pages analysées.

  • La home en 17e : normal. Elle survole tous tes sujets, donc elle colle rarement à la moyenne. 17e, c'est toujours le cœur.

  • Les fiches produits en tête : comme elles sont nombreuses et se ressemblent, elles tirent le centre vers elles. Un gros score veut dire "page typique du site", pas "page forte".

  • Ce qu'on en déduit : le score sert surtout à repérer les pages hors sujet (les 10 % du bas). Il ne dit rien de leur puissance.

  • Pour mailler une page éloignée : ne prends pas les meilleurs scores, prends la colonne "page la plus proche" du CSV. C'est sa voisine sémantique, donc le lien le plus logique.

Et si ce sont tes produits qui font le centre, c'est une info en soi : ton site parle d'abord "catalogue". Si tu veux qu'il parle d'abord "expertise", c'est le contenu éditorial qu'il faut renforcer :)

N'hésite pas à nous publier le screen du svg c'est toujours sympa à voir !


⌁ NET-LABS — SEO INTELLIGENCE.
    Discord • SemSeeker • SemSpider

1
J'aime ❤️

En ligne

#4 script, liens, formations

StoneScout
144 messages30 j'aimedepuis 2016Montpellier
Distinctions · 8
10 ansPilier IIIStratège IIAppréciéPhilanthrope IIClinicien IIAccueillant IIExpert SEO

Re : Fuite Google Content Warehouse attributs : siteFocusScore siteRadius

Non merci à toi surtout.

Ok donc, moi perso ça me va si le site est perçu comme un site catalogue : Woocommerce de vente en ligne de formations, pourtant d'aspect plus édito / pages de prestation.
Le but est bien de vendre des inscriptions aux formations : nickel.

Donc si j'ai bien compris :

  • le script note la typologie du site, la thématisation des pages ;

  • Plus la page est thématisée sur un sujet précis, mieux elle est notée

Pour approcher les pages éloignées du centre et les optimiser, il faudrait :

  • que je rethématise le contexte ?

  • que je maille depuis la page la plus proche ?

les liens qui sont situés dans le préfooter (bloc formations related) ne sont pas considérés / pris en compte dans le calcul ?

J'ai bon ?

0
J'aime ❤️

Hors ligne

#5

JaffaarGuardianAuteur
8 744 messages1 434 j'aimedepuis 2012Consultant SEO / WEB / IA
Site Web
Distinctions · 22
Pilier VIIIPhilanthrope VIIPremier secours VIIAccueillant VI12 ansAdministrateurKilluavieConsommateur de liensÉminentClinicien VExpert SEO VForce polyvalenteExpert IA et GEO IVExpert Outils et technique IIIStratège IIAutomate IISérie IIRéactionsExpert Multi-canalExpert BusinessIngénieur webBusiness man

Re : Fuite Google Content Warehouse attributs : siteFocusScore siteRadius

que je rethématise le contexte ?

Oui, le contexte des pages


que je maille depuis la page la plus proche ?

Pour cette partie pas forcement, pour le seo en soi (au dela des deux algo de ce thread) oui :)

C'est normal d'avoir des pages un peu éloignée du coeur je pense, il faut prendre cela avec des pincettes car ce n'est qu'une partie de l'algo global,
mais maintenant il est possible pour les pages éloignées de les rapprocher en ajoutant du vocabulaire pour mieux mélanger les deux théme et mieux faire le pont entres les sets lexicaux respectifs.

L'idée c'est de minimiser le dilution de l'autorité thématique du site en resserant un peu les mailles sans non plus optimiser à l'extreme, il y a surement des exceptions légitimes à respecter sur nombre de projets.


⌁ NET-LABS — SEO INTELLIGENCE.
    Discord • SemSeeker • SemSpider

1
J'aime ❤️

En ligne

#6 google

RecreaboxScout
86 messages22 j'aimedepuis 2026Paris
Site Web
Distinctions · 11
Force polyvalenteAccueillant IIIStratège IIAppréciéSérie IIRéactionsPilier IIClinicienPremier secours IIIngénieur webAutomate

Re : Fuite Google Content Warehouse attributs : siteFocusScore siteRadius

Franchement c'est sympa comme outil !

Je viens d'essayer et la visualisation parle d'elle même. Ca permet de comprendre comment Google voit votre site en terme d'autorité thématique, et sur quels sujets il faut se concentrer.

Capture-decran-2026-11-17-a-23.34.19.png

1
J'aime ❤️

Hors ligne

#7 maillage, liens, sémantique, thématique, groupes

JaffaarGuardianAuteur
8 744 messages1 434 j'aimedepuis 2012Consultant SEO / WEB / IA
Site Web
Distinctions · 22
Pilier VIIIPhilanthrope VIIPremier secours VIIAccueillant VI12 ansAdministrateurKilluavieConsommateur de liensÉminentClinicien VExpert SEO VForce polyvalenteExpert IA et GEO IVExpert Outils et technique IIIStratège IIAutomate IISérie IIRéactionsExpert Multi-canalExpert BusinessIngénieur webBusiness man

Re : Fuite Google Content Warehouse attributs : siteFocusScore siteRadius

@Stone ces deux scores et le graph ne prennent pas du tout en compte les liens ou le maillage mais la thématisation du groupe de page et de chaque page pour situer la distribution thématique pure en quelques sortes.

Par thématique 'pure' j'entends : liée a la sémantique des termes portés par les pages et non au maillage et a la structure qui relie les pages.

@Recreabox on voit directement 3 petits groupes de pages (en rouge) pour lesquels tu pourrais peut être un peu resserer les mailles en ajoutant une meilleur jonctions contextuelle entre le coeur et les groupes excentrés :)


⌁ NET-LABS — SEO INTELLIGENCE.
    Discord • SemSeeker • SemSpider

👍 1
0
J'aime ❤️

En ligne

Accueil › Contenu et sémantique › Fuite Google Content Warehouse attributs : siteFocusScore siteRadius

Haut

Pied de page des forums