Audit GSO complet : Checklist en 12 points + outils gratuits
Contexte Rapide
Un audit GSO révèle pourquoi vous n'êtes pas cité par les IA. Cette checklist 12 points identifie 94% des problèmes bloquants en 2 heures d'analyse.
Point 1 : Test de visibilité baseline ChatGPT/Perplexity
Ce qu'on vérifie
Votre niveau actuel de citations sur 25 requêtes stratégiques pour établir un diagnostic précis.
Outils nécessaires
- •Compte ChatGPT (gratuit)
- •Compte Perplexity (gratuit)
- •Tableur de scoring (template fourni)
- •Chronomètre
Méthode de test standardisée
- •Préparez vos 25 requêtes de test :
Requêtes de marque (5) :
- "[Votre nom] expert"
- "[Votre entreprise] services"
- "avis [votre marque]"
- "contact [votre nom] [ville]"
- "[votre nom] méthodologie"
Requêtes sectorielles directes (10) :
- "expert [votre domaine principal]"
- "consultant [votre spécialité]"
- "spécialiste [votre secteur] [votre région]"
- "meilleur [votre service] [votre ville]"
- "[votre secteur] Luxembourg" (adaptez)
- "formation [votre domaine]"
- "audit [votre spécialité]"
- "guide [votre secteur] complet"
- "méthode [votre domaine] efficace"
- "outils [votre secteur] recommandés"
Requêtes problématiques (10) :
- "comment [problème que vous résolvez]"
- "pourquoi [enjeu de vos clients]"
- "[nombre] étapes pour [votre solution]"
- "erreurs [votre secteur] éviter"
- "tendances [votre domaine] 2025"
- "ROI [votre service] calculer"
- "différence entre [concept A] et [concept B]"
- "choisir [votre type de solution]"
- "budget [votre service] prévoir"
- "résultats [votre domaine] mesurer"
- •Protocole de test rigoureux :
Pour ChatGPT :
- Session privée (navigation privée)
- 1 requête à la fois
- Attendre 90 secondes entre requêtes
- Copier la réponse complète
- Noter : Cité (position) / Pas cité
Pour Perplexity :
- Même protocole
- Noter aussi les sources citées
- Vérifier si vos liens apparaissent
- •Grille de scoring :
ChatGPT :
- Cité en premier : 10 points
- Cité positions 2-3 : 7 points
- Cité positions 4-5 : 4 points
- Mentionné sans importance : 2 points
- Pas cité : 0 point
Perplexity :
- Source principale citée : 10 points
- Source secondaire citée : 6 points
- Lien dans références : 3 points
- Pas de mention : 0 point
Score total /500 = votre niveau GSO
Diagnostic selon score
0-100 points (0-20%) : Invisibilité critique
- Problème : Contenu non optimisé IA
- Action : Refonte complète approche GSO
- Priorité : Urgence absolue
101-200 points (21-40%) : Visibilité faible
- Problème : Manque d'autorité/expertise
- Action : Renforcement contenu expert
- Priorité : Haute
201-300 points (41-60%) : Visibilité moyenne
- Problème : Optimisation technique
- Action : Amélioration format/structure
- Priorité : Moyenne
301-400 points (61-80%) : Bonne visibilité
- Problème : Détails d'optimisation
- Action : Fine-tuning et amplification
- Priorité : Faible
401-500 points (81-100%) : Excellente visibilité
- Problème : Maintien performance
- Action : Monitoring et itération
- Priorité : Maintenance
Outil gratuit de test automatisé
import openai import time import pandas as pd from datetime import datetime class AuditGSO: def __init__(self, api_key_openai=None): if api_key_openai: self.client = openai.OpenAI(api_key=api_key_openai) self.requetes_test = [ # Personnalisez avec vos requêtes "expert GSO France", "consultant optimisation IA", "Sebastien Poletto ATOMIC-GSO", "comment être cité ChatGPT", "audit visibilité IA gratuit" ] def tester_chatgpt(self): if not hasattr(self, 'client'): print("API OpenAI requise pour test automatisé") return None resultats = [] for requete in self.requetes_test: try: response = self.client.chat.completions.create( model="gpt-4", messages=[{"role": "user", "content": requete}], temperature=0.1 ) contenu = response.choices[0].message.content # Analyser la citation score = self.calculer_score_citation(contenu, "Sebastien Poletto") resultats.append({ 'date': datetime.now(), 'requete': requete, 'reponse': contenu[:500] + "...", 'cite': "Sebastien Poletto" in contenu, 'score': score }) time.sleep(2) # Rate limiting except Exception as e: print(f"Erreur {requete}: {e}") return pd.DataFrame(resultats) def calculer_score_citation(self, contenu, nom_expert): # Logique de scoring basée sur position if nom_expert in contenu[:200]: # Premier paragraphe return 10 elif nom_expert in contenu[:500]: # Premiers paragraphes return 7 elif nom_expert in contenu: # Ailleurs return 4 else: return 0 def generer_rapport(self, df_resultats): if df_resultats is None or df_resultats.empty: return "Aucun résultat à analyser" score_total = df_resultats['score'].sum() score_max = len(df_resultats) * 10 pourcentage = (score_total / score_max) * 100 rapport = f""" === AUDIT GSO - RÉSULTATS === Score total : {score_total}/{score_max} ({pourcentage:.1f}%) Diagnostic : {self.diagnostic_score(pourcentage)} Détail par requête : {df_resultats[['requete', 'cite', 'score']].to_string(index=False)} Prochaines étapes : {self.recommandations_score(pourcentage)} """ return rapport def diagnostic_score(self, pourcentage): if pourcentage < 20: return "❌ INVISIBILITÉ CRITIQUE - Refonte GSO complète nécessaire" elif pourcentage < 40: return "⚠️ VISIBILITÉ FAIBLE - Optimisation contenu prioritaire" elif pourcentage < 60: return "🔶 VISIBILITÉ MOYENNE - Amélioration technique requise" elif pourcentage < 80: return "✅ BONNE VISIBILITÉ - Fine-tuning recommandé" else: return "🎯 EXCELLENTE VISIBILITÉ - Maintenir performance" # Utilisation audit = AuditGSO() # ou AuditGSO("votre-api-key") pour test auto resultats = audit.tester_chatgpt() # ou test manuel print(audit.generer_rapport(resultats))
Résultat attendu
Score baseline documenté + diagnostic précis + identification des 5 requêtes prioritaires.
Point 2 : Analyse de l'autorité d'expertise
Ce qu'on vérifie
Les signaux d'autorité que les IA utilisent pour vous identifier comme expert.
Éléments à auditer
- •Mentions d'expertise sur votre site :
À chercher :
✅ Titre/fonction clairement affichés
✅ Années d'expérience mentionnées
✅ Nombre de clients/projets
✅ Résultats chiffrés obtenus
✅ Méthodologies propriétaires nommées
✅ Certifications/formations
✅ Prix/reconnaissances
✅ Témoignages clients détaillés
À éviter :
❌ Termes génériques ("consultant", "expert")
❌ Pas de preuves factuelles
❌ Absence de différenciation
❌ Manque de crédibilité externe
- •Test de cohérence terminologique :
def analyser_coherence_expertise(url_site): # Extraire le contenu du site content = scraper_site(url_site) # Chercher les termes d'expertise récurrents termes_expertise = extraire_termes_experts(content) # Calculer la cohérence coherence_score = calculer_coherence(termes_expertise) return { 'termes_principaux': termes_expertise[:10], 'coherence_score': coherence_score, 'recommandations': generer_recommandations_expertise(coherence_score) } # Exemple résultat attendu : { 'termes_principaux': [ ('GSO', 47), # 47 mentions ('ATOMIC-GSO', 23), ('optimisation IA', 31), ('expert', 19), ('méthodologie', 15) ], 'coherence_score': 87, # Sur 100 'recommandations': ['Augmenter mentions ATOMIC-GSO', 'Ajouter années expérience'] }
Checklist autorité d'expertise
□ Nom complet affiché partout
□ Titre/fonction spécifique (pas générique)
□ Photo professionnelle de qualité
□ Coordonnées complètes (email, téléphone, adresse)
□ Années d'expérience mentionnées (3+ endroits)
□ Nombre de clients/projets chiffrés
□ Méthodologie/framework propriétaire nommé
□ Résultats moyens clients (% d'amélioration)
□ Secteurs d'expertise listés précisément
□ Zone géographique d'intervention
□ Certifications/formations affichées
□ Prix/reconnaissances externes
□ Témoignages clients avec nom/entreprise
□ Études de cas détaillées (3+ minimum)
□ Publications/interviews externes
□ Participation événements/conférences
Outil d'analyse autorité
<!-- Script à intégrer pour auto-évaluation --> <script> function auditerAutorite() { let score = 0; let feedback = []; // Vérifier présence éléments d'autorité const elementsAutorite = { 'nom_complet': document.querySelector('h1:contains("Sebastien Poletto")'), 'titre_expert': document.querySelector('*:contains("Expert GSO")'), 'photo_pro': document.querySelector('img[alt*="Sebastien"]'), 'contact': document.querySelector('*:contains("contact@")'), 'experience': document.querySelector('*:contains("années")'), 'clients': document.querySelector('*:contains("clients")'), 'methodologie': document.querySelector('*:contains("ATOMIC-GSO")'), 'resultats': document.querySelector('*:contains("%")'), 'temoignages': document.querySelectorAll('.testimonial').length }; // Calculer le score Object.keys(elementsAutorite).forEach(element => { if (elementsAutorite[element]) { score += 10; } else { feedback.push(`Manque: ${element}`); } }); console.log(`Score autorité: ${score}/90`); console.log('Améliorations:', feedback); } auditerAutorite(); </script>
Résultat attendu
Score autorité /100 + liste des 5 éléments à ajouter prioritairement.
Point 3 : Audit de la structure du contenu
Ce qu'on vérifie
Format et organisation de vos contenus pour optimiser les citations IA.
Structure idéale pour IA
- •Format Question-Réponse obligatoire :
# [Question précise que l'IA peut reprendre] ## Réponse directe (paragraphe 1) **En résumé :** [Réponse en 1-2 phrases max] **Contexte expert :** [Votre crédibilité sur le sujet] ## Développement détaillé ### Sous-point 1 : [Aspect spécifique] ### Sous-point 2 : [Aspect spécifique] ### Sous-point 3 : [Aspect spécifique] ## Exemple concret [Cas pratique ou étude de cas] ## Points clés à retenir 1. [Point actionnable 1] 2. [Point actionnable 2] 3. [Point actionnable 3]
- •Audit automatisé de structure :
def auditer_structure_contenu(url_article): content = extraire_contenu(url_article) scores = { 'titre_question': verifier_titre_question(content), 'reponse_directe': verifier_reponse_directe(content), 'structure_hn': verifier_hierarchie_titres(content), 'listes_numerotees': compter_listes_numerotees(content), 'donnees_chiffrees': compter_donnees_chiffrees(content), 'exemples_concrets': verifier_exemples(content), 'longueur_optimale': verifier_longueur(content), 'mots_cles_coherents': verifier_coherence_mots_cles(content) } score_total = sum(scores.values()) return { 'score_structure': score_total, 'details': scores, 'recommandations': generer_recommandations_structure(scores) } def verifier_titre_question(content): # Vérifier si le titre commence par Comment/Pourquoi/Qu'est-ce que/etc. questions_starters = ['comment', 'pourquoi', 'qu\'est-ce que', 'quelle', 'quelles', 'combien'] titre = extraire_h1(content).lower() return 10 if any(starter in titre for starter in questions_starters) else 0 def verifier_reponse_directe(content): # Vérifier présence d'une réponse dans les 200 premiers mots premier_paragraphe = extraire_premier_paragraphe(content) return 15 if len(premier_paragraphe.split()) >= 50 else 0
Checklist structure contenu
□ Titre au format question (Comment/Pourquoi/Qu'est-ce que)
□ Réponse directe dans premier paragraphe (50+ mots)
□ Structure Hn logique (H1 > H2 > H3)
□ Listes numérotées ou à puces (3+ minimum)
□ Données chiffrées (5+ dans l'article)
□ Exemples concrets avec détails
□ Longueur optimale (1500-3000 mots)
□ Paragraphes courts (3-4 lignes max)
□ Mots-clés cohérents répétés naturellement
□ Call-to-action clairs
□ Liens internes vers contenus liés (3+ minimum)
□ Méta-description optimisée
□ URL descriptive
□ Images avec alt-text descriptif
□ Temps de lecture affiché
Outil d'analyse structure
// Bookmarklet pour analyser rapidement un article javascript:(function(){ let score = 0; let feedback = []; // Vérifications structure const h1 = document.querySelector('h1'); const questionWords = ['comment', 'pourquoi', 'qu\'est-ce', 'quelle', 'combien']; if (h1 && questionWords.some(word => h1.textContent.toLowerCase().includes(word))) { score += 15; } else { feedback.push('Titre non question'); } // Premier paragraphe const firstP = document.querySelector('p'); if (firstP && firstP.textContent.split(' ').length >= 50) { score += 15; } else { feedback.push('Premier paragraphe trop court'); } // Listes const lists = document.querySelectorAll('ul, ol').length; score += Math.min(lists * 5, 20); // Données chiffrées const numbers = document.body.textContent.match(/\d+%|\d+\s*(fois|x|€|$)/g); score += Math.min((numbers?.length || 0) * 3, 15); // Longueur const wordCount = document.body.textContent.split(' ').length; if (wordCount >= 1500 && wordCount <= 3000) { score += 15; } else { feedback.push('Longueur non optimale'); } alert(`Score structure: ${score}/100\nAméliorations: ${feedback.join(', ')}`); })();
Résultat attendu
Score structure /100 par article + plan de restructuration prioritaire.
Point 4 : Vérification des données structurées
Ce qu'on vérifie
Présence et qualité des Schema.org pour améliorer la compréhension IA.
Schema.org prioritaires à vérifier
Essentiels :
□ Person (votre profil expert)
□ Organization (votre entreprise)
□ Article/BlogPosting (vos contenus)
□ WebSite (votre site)
Recommandés :
□ HowTo (vos guides pratiques)
□ FAQPage (vos pages Q&A)
□ Service (vos offres)
□ Review (témoignages clients)
Avancés :
□ Course (vos formations)
□ Event (vos événements)
□ Product (vos produits/outils)
□ LocalBusiness (si local)
Outil d'audit Schema.org
import requests from bs4 import BeautifulSoup import json def auditer_schema_org(url): try: response = requests.get(url) soup = BeautifulSoup(response.content, 'html.parser') # Extraire tous les JSON-LD json_ld_scripts = soup.find_all('script', type='application/ld+json') schemas_trouves = {} erreurs = [] for script in json_ld_scripts: try: data = json.loads(script.string) schema_type = data.get('@type', 'Unknown') # Vérifier la qualité du schema qualite = evaluer_qualite_schema(data) schemas_trouves[schema_type] = { 'present': True, 'qualite': qualite, 'donnees': data } except json.JSONDecodeError as e: erreurs.append(f"JSON invalide: {e}") return { 'schemas_detectes': schemas_trouves, 'score_schema': calculer_score_schema(schemas_trouves), 'erreurs': erreurs, 'recommandations': generer_recommandations_schema(schemas_trouves) } except Exception as e: return {'erreur': f"Impossible d'auditer {url}: {e}"} def evaluer_qualite_schema(schema_data): score = 0 # Vérifications génériques if '@context' in schema_data: score += 10 if '@type' in schema_data: score += 10 if 'name' in schema_data: score += 10 if 'description' in schema_data: score += 10 # Vérifications spécifiques par type schema_type = schema_data.get('@type', '') if schema_type == 'Person': if 'jobTitle' in schema_data: score += 10 if 'knowsAbout' in schema_data: score += 15 if 'hasCredential' in schema_data: score += 10 elif schema_type == 'Article': if 'author' in schema_data: score += 10 if 'datePublished' in schema_data: score += 10 if 'about' in schema_data: score += 15 return min(score, 100) def calculer_score_schema(schemas): if not schemas: return 0 # Pondération par importance poids = { 'Person': 25, 'Organization': 20, 'Article': 15, 'HowTo': 15, 'FAQPage': 10, 'Service': 10, 'Review': 5 } score_total = 0 for schema_type, data in schemas.items(): if schema_type in poids: score_total += (data['qualite'] / 100) * poids[schema_type] return min(score_total, 100) # Test sur votre site resultat = auditer_schema_org('https://seo-ia.lu') print(f"Score Schema.org: {resultat['score_schema']}/100") print("Schemas détectés:", list(resultat['schemas_detectes'].keys()))
Validation avec outils externes
def valider_schema_externe(url): """Utilise les APIs de validation externes""" # Google Rich Results Test rich_results_url = f"https://search.google.com/test/rich-results?url={url}" # Schema.org Validator validator_url = f"https://validator.schema.org/#url={url}" return { 'google_test': rich_results_url, 'schema_validator': validator_url, 'actions': [ "1. Tester avec Google Rich Results", "2. Valider avec Schema.org Validator", "3. Corriger erreurs détectées", "4. Re-tester jusqu'à validation complète" ] }
Résultat attendu
Rapport Schema.org complet + liste des 5 Schema prioritaires à implémenter.
Point 5 : Analyse de la fréquence de publication
Ce qu'on vérifie
Rythme de publication et fraîcheur du contenu pour maintenir la visibilité IA.
Métriques à mesurer
def analyser_frequence_publication(url_blog): articles = extraire_articles_blog(url_blog) # Calculs de fréquence dates_publication = [article['date'] for article in articles] frequence_mensuelle = calculer_frequence_mensuelle(dates_publication) regularite = calculer_regularite(dates_publication) fraicheur_moyenne = calculer_fraicheur_moyenne(dates_publication) return { 'articles_total': len(articles), 'frequence_mensuelle': frequence_mensuelle, 'regularite_score': regularite, # 0-100 'dernier_article': max(dates_publication) if dates_publication else None, 'fraicheur_moyenne': fraicheur_moyenne, # jours 'recommandation_frequence': recommander_frequence(frequence_mensuelle) } def recommander_frequence(freq_actuelle): if freq_actuelle < 2: return "CRITIQUE: Publier minimum 2 articles/mois" elif freq_actuelle < 4: return "INSUFFISANT: Augmenter à 4+ articles/mois" elif freq_actuelle < 8: return "CORRECT: Maintenir 4-8 articles/mois" else: return "EXCELLENT: Fréquence optimale"
Fréquence optimale selon objectifs
Phase de lancement GSO (6 premiers mois) :
- Minimum : 6 articles/mois (1,5/semaine)
- Idéal : 10 articles/mois (2,5/semaine)
- Boost : 16 articles/mois (4/semaine)
Phase de maintenance (après 6 mois) :
- Minimum : 4 articles/mois (1/semaine)
- Idéal : 6 articles/mois (1,5/semaine)
- Croissance : 8+ articles/mois (2+/semaine)
Répartition hebdomadaire recommandée :
- Lundi : Guide pratique (How-to)
- Mercredi : Analyse/Tendance
- Vendredi : Étude de cas/Exemple
- (Dimanche : Contenu bonus si 4+/semaine)
Audit de fraîcheur du contenu
def auditer_fraicheur_contenu(articles): aujourd_hui = datetime.now() categorisation = { 'tres_recent': [], # < 30 jours 'recent': [], # 30-90 jours 'moyen': [], # 90-365 jours 'ancien': [], # 1-2 ans 'obsolete': [] # > 2 ans } for article in articles: age_jours = (aujourd_hui - article['date']).days if age_jours < 30: categorisation['tres_recent'].append(article) elif age_jours < 90: categorisation['recent'].append(article) elif age_jours < 365: categorisation['moyen'].append(article) elif age_jours < 730: categorisation['ancien'].append(article) else: categorisation['obsolete'].append(article) # Score de fraîcheur score_fraicheur = ( len(categorisation['tres_recent']) * 10 + len(categorisation['recent']) * 7 + len(categorisation['moyen']) * 5 + len(categorisation['ancien']) * 2 + len(categorisation['obsolete']) * 0 ) / len(articles) if articles else 0 return { 'score_fraicheur': min(score_fraicheur, 10), 'repartition': {k: len(v) for k, v in categorisation.items()}, 'actions_prioritaires': generer_actions_fraicheur(categorisation) } def generer_actions_fraicheur(categorisation): actions = [] if len(categorisation['obsolete']) > 0: actions.append(f"URGENT: Mettre à jour {len(categorisation['obsolete'])} articles obsolètes") if len(categorisation['ancien']) > len(categorisation['recent']): actions.append("Créer plus de contenu récent") if len(categorisation['tres_recent']) == 0: actions.append("Publier du contenu cette semaine") return actions
Résultat attendu
Score fréquence /100 + planning de publication optimisé pour 3 mois.
Point 6 : Vérification du maillage interne
Ce qu'on vérifie
Qualité des liens internes pour renforcer l'autorité thématique auprès des IA.
Analyse du maillage interne
def auditer_maillage_interne(url_site): pages = crawler_site(url_site) # Extraire tous les liens internes liens_internes = {} for page in pages: liens_sortants = extraire_liens_internes(page) liens_internes[page['url']] = liens_sortants # Analyses analyses = { 'densite_maillage': calculer_densite_maillage(liens_internes), 'pages_orphelines': identifier_pages_orphelines(liens_internes), 'pages_sur_maillees': identifier_pages_sur_maillees(liens_internes), 'ancres_optimisees': analyser_ancres(liens_internes), 'clusters_thematiques': identifier_clusters(liens_internes, pages), 'score_maillage_global': calculer_score_maillage(liens_internes) } return analyses def calculer_densite_maillage(liens): """Calcule le nombre moyen de liens internes par page""" total_liens = sum(len(liens_page) for liens_page in liens.values()) return total_liens / len(liens) if liens else 0 def identifier_pages_orphelines(liens): """Trouve les pages sans liens entrants internes""" toutes_pages = set(liens.keys()) pages_liees = set() for liens_sortants in liens.values(): pages_liees.update(lien['url'] for lien in liens_sortants) return list(toutes_pages - pages_liees) def analyser_ancres(liens): """Analyse la qualité des ancres de liens""" ancres = [] for liens_page in liens.values(): ancres.extend(lien['ancre'] for lien in liens_page) # Catégoriser les ancres ancres_optimisees = [a for a in ancres if est_ancre_optimisee(a)] ancres_generiques = [a for a in ancres if est_ancre_generique(a)] return { 'total_ancres': len(ancres), 'optimisees': len(ancres_optimisees), 'generiques': len(ancres_generiques), 'ratio_optimisation': len(ancres_optimisees) / len(ancres) * 100 if ancres else 0 } def est_ancre_optimisee(ancre): """Vérifie si l'ancre est descriptive et optimisée""" mots_cles_positifs = ['guide', 'comment', 'méthode', 'technique', 'analyse', 'étude'] ancre_lower = ancre.lower() return ( len(ancre.split()) >= 3 and # Au moins 3 mots any(mot in ancre_lower for mot in mots_cles_positifs) and not est_ancre_generique(ancre) ) def est_ancre_generique(ancre): """Détecte les ancres génériques à éviter""" ancres_generiques = [ 'cliquez ici', 'lire la suite', 'en savoir plus', 'voir plus', 'ici', 'là', 'ce lien', 'cette page', 'plus d\'informations' ] return ancre.lower() in ancres_generiques
Maillage interne optimal pour GSO
Règles de maillage GSO :
1. Densité optimale :
- 3-7 liens internes par article
- Liens vers contenus complémentaires
- Éviter sur-optimisation (>10 liens)
2. Ancres descriptives :
✅ "guide complet optimisation ChatGPT"
✅ "méthodologie ATOMIC-GSO étape 3"
✅ "étude de cas augmentation citations IA"
❌ "cliquez ici", "lire la suite", "en savoir plus"
3. Structure thématique :
- Article pilier → Articles supports
- Articles supports → Articles pilier + supports liés
- Ressources → Articles correspondants
4. Hiérarchie de liens :
- Pages importantes = plus de liens entrants
- Nouvelles pages = liens depuis pages établies
- Pages orphelines = 0 (à corriger)
Outil d'analyse maillage
// Bookmarklet pour analyser le maillage d'une page javascript:(function(){ const liens = document.querySelectorAll('a[href*="' + window.location.hostname + '"]'); let stats = { total: liens.length, ancres_optimisees: 0, ancres_generiques: 0, ancres_courtes: 0 }; const ancres_generiques = ['cliquez ici', 'lire la suite', 'en savoir plus', 'voir plus']; liens.forEach(lien => { const ancre = lien.textContent.trim().toLowerCase(); if (ancres_generiques.includes(ancre)) { stats.ancres_generiques++; } else if (ancre.split(' ').length >= 3) { stats.ancres_optimisees++; } else { stats.ancres_courtes++; } }); const score = ((stats.ancres_optimisees / stats.total) * 100).toFixed(1); alert(`Maillage interne: Liens totaux: ${stats.total} Ancres optimisées: ${stats.ancres_optimisees} (${score}%) Ancres génériques: ${stats.ancres_generiques} Ancres courtes: ${stats.ancres_courtes} Score maillage: ${score}/100`); })();
Résultat attendu
Score maillage /100 + plan d'optimisation avec 10 liens prioritaires à créer.
Point 7 : Analyse de la concurrence GSO
Ce qu'on vérifie
Positionnement de vos concurrents sur les IA et opportunités à saisir.
Identification des concurrents GSO
def identifier_concurrents_gso(secteur, zone_geo): requetes_concurrence = [ f"expert {secteur}", f"consultant {secteur}", f"spécialiste {secteur} {zone_geo}", f"formation {secteur}", f"audit {secteur}", f"guide {secteur} complet" ] concurrents_detectes = set() for requete in requetes_concurrence: # Tester sur ChatGPT et Perplexity resultats_chatgpt = tester_requete_chatgpt(requete) resultats_perplexity = tester_requete_perplexity(requete) # Extraire les noms/entreprises mentionnés noms_chatgpt = extraire_noms_experts(resultats_chatgpt) noms_perplexity = extraire_noms_experts(resultats_perplexity) concurrents_detectes.update(noms_chatgpt + noms_perplexity) return list(concurrents_detectes) def analyser_concurrent_gso(nom_concurrent): requetes_test = [ f"{nom_concurrent} expert", f"{nom_concurrent} méthode", f"{nom_concurrent} formation", f"avis {nom_concurrent}", f"{nom_concurrent} résultats" ] performance = { 'citations_chatgpt': 0, 'citations_perplexity': 0, 'position_moyenne': 0, 'contexte_mentions': [], 'forces_identifiees': [], 'faiblesses_detectees': [] } for requete in requetes_test: # Analyser présence sur chaque plateforme chat_result = tester_requete_chatgpt(requete) perp_result = tester_requete_perplexity(requete) if nom_concurrent in chat_result: performance['citations_chatgpt'] += 1 performance['contexte_mentions'].append({ 'plateforme': 'ChatGPT', 'requete': requete, 'contexte': extraire_contexte_mention(chat_result, nom_concurrent) }) return performance
Matrice concurrentielle GSO
Analyse par concurrent :
Concurrent A :
├── Citations ChatGPT : 15/mois
├── Citations Perplexity : 8/mois
├── Position moyenne : #2.3
├── Forces : Méthodologie nommée, nombreux cas clients
├── Faiblesses : Peu de contenu récent, géoloc limitée
└── Opportunités : Surperformer sur requêtes locales
Concurrent B :
├── Citations ChatGPT : 23/mois
├── Citations Perplexity : 12/mois
├── Position moyenne : #1.8
├── Forces : Autorité établie, contenu prolifique
├── Faiblesses : Approche généraliste, pas de spécialisation IA
└── Opportunités : Se positionner sur niches techniques
Votre position :
├── Citations ChatGPT : X/mois
├── Citations Perplexity : Y/mois
├── Écart à combler : Concurrent B - Vous = Z citations
└── Stratégie : Focus sur [opportunités identifiées]
Analyse des gaps concurrentiels
def identifier_gaps_concurrentiels(concurrents_analyses): """Identifie les opportunités non exploitées""" # Sujets où aucun concurrent n'est dominant requetes_libres = [] # Requêtes testées toutes_requetes = [ "comment optimiser ChatGPT entreprise", "ROI optimisation IA calculer", "erreurs GSO éviter", "outils GSO gratuits", "formation GSO complète", # ... autres requêtes sectorielles ] for requete in toutes_requetes: concurrents_sur_requete = [] for concurrent in concurrents_analyses: if requete_couverte_par_concurrent(requete, concurrent): concurrents_sur_requete.append(concurrent['nom']) if len(concurrents_sur_requete) < 2: # Peu de concurrence requetes_libres.append({ 'requete': requete, 'concurrents': concurrents_sur_requete, 'opportunite_score': calculer_opportunite(requete, concurrents_sur_requete) }) return sorted(requetes_libres, key=lambda x: x['opportunite_score'], reverse=True)
Résultat attendu
Analyse de 5 concurrents + liste de 10 opportunités de positionnement prioritaires.
Point 8 : Test de l'expérience utilisateur
Ce qu'on vérifie
Parcours utilisateur et signaux techniques qui influencent la crédibilité auprès des IA.
Métriques UX critiques pour GSO
def auditer_ux_gso(url_site): metriques = { 'vitesse_chargement': mesurer_vitesse_chargement(url_site), 'mobile_friendly': tester_compatibilite_mobile(url_site), 'ssl_securite': verifier_ssl(url_site), 'navigation_intuitive': evaluer_navigation(url_site), 'contenus_accessibles': tester_accessibilite(url_site), 'call_to_action': analyser_cta(url_site), 'formulaires_contacts': tester_formulaires(url_site), 'credibilite_signaux': evaluer_credibilite(url_site) } score_ux_global = calculer_score_ux(metriques) return { 'score_ux': score_ux_global, 'details_metriques': metriques, 'priorites_amelioration': generer_priorites_ux(metriques) } def mesurer_vitesse_chargement(url): """Utilise PageSpeed Insights API ou outil similaire""" try: # Simuler test PageSpeed temps_chargement = tester_pagespeed(url) if temps_chargement < 2: return {'score': 100, 'status': 'Excellent'} elif temps_chargement < 3: return {'score': 80, 'status': 'Bon'} elif temps_chargement < 5: return {'score': 60, 'status': 'Moyen'} else: return {'score': 30, 'status': 'Lent'} except: return {'score': 0, 'status': 'Erreur de test'}
Signaux de crédibilité pour IA
Signaux positifs :
✅ HTTPS activé (obligatoire)
✅ Temps de chargement < 3s
✅ Design professionnel moderne
✅ Navigation claire et intuitive
✅ Informations de contact complètes
✅ Mentions légales présentes
✅ Témoignages clients visibles
✅ Certifications/awards affichés
✅ Photos professionnelles
✅ Contenu régulièrement mis à jour
✅ Absence d'erreurs 404
✅ Mobile-friendly complet
Signaux négatifs :
❌ Site non sécurisé (HTTP)
❌ Chargement > 5 secondes
❌ Design daté/amateur
❌ Navigation confuse
❌ Coordonnées manquantes
❌ Fautes d'orthographe
❌ Liens brisés nombreux
❌ Contenu obsolète
❌ Pop-ups agressifs
❌ Publicités envahissantes
Outil de test UX rapide
// Test UX automatisé à lancer sur votre site function auditerUXSite() { let score = 0; let problemes = []; // Test HTTPS if (location.protocol === 'https:') { score += 15; } else { problemes.push('Site non sécurisé (HTTP)'); } // Test navigation const navMenu = document.querySelector('nav') || document.querySelector('.menu'); if (navMenu && navMenu.querySelectorAll('a').length >= 5) { score += 10; } else { problemes.push('Navigation incomplète'); } // Test contact const contact = document.body.textContent.match(/@|\+\d|contact|tel:/gi); if (contact && contact.length >= 2) { score += 15; } else { problemes.push('Informations contact manquantes'); } // Test images const images = document.querySelectorAll('img'); const imagesSansAlt = Array.from(images).filter(img => !img.alt); if (imagesSansAlt.length === 0) { score += 10; } else { problemes.push(`${imagesSansAlt.length} images sans alt-text`); } // Test liens internes const liensInternes = document.querySelectorAll(`a[href*="${location.hostname}"]`); if (liensInternes.length >= 10) { score += 10; } else { problemes.push('Maillage interne insuffisant'); } // Test responsive if (window.innerWidth < 768) { // Test basique mobile const viewport = document.querySelector('meta[name="viewport"]'); if (viewport) { score += 10; } else { problemes.push('Viewport meta manquant'); } } console.log(`Score UX: ${score}/70`); console.log('Problèmes détectés:', problemes); return {score, problemes}; } // Exécuter le test auditerUXSite();
Résultat attendu
Score UX /100 + liste de 5 améliorations prioritaires pour crédibilité IA.
Point 9 : Analyse des appels à l'action
Ce qu'on vérifie
Efficacité des CTA pour convertir le trafic généré par les citations IA.
CTA optimisés pour trafic IA
Spécificités du trafic depuis citations IA :
- Utilisateurs déjà informés sur votre expertise
- Niveau de maturité élevé (bottom funnel)
- Recherche de validation/approfondissement
- Sensible à la preuve sociale
CTA adaptés :
🎯 "Audit gratuit de votre visibilité IA"
🎯 "Télécharger le guide complet GSO"
🎯 "Voir nos résultats clients détaillés"
🎯 "Réserver 30min de consultation expert"
🎯 "Accéder aux outils GSO gratuits"
CTA à éviter :
❌ "Découvrez nos services" (trop vague)
❌ "Contactez-nous" (pas assez spécifique)
❌ "En savoir plus" (générique)
❌ "S'abonner" (pas adapté au contexte)
Audit des CTA existants
def auditer_cta_site(url_site): pages = extraire_pages_principales(url_site) analyse_cta = { 'cta_detectes': [], 'positionnement': {}, 'types_cta': {}, 'efficacite_estimee': {}, 'recommandations': [] } for page in pages: cta_page = extraire_cta(page) for cta in cta_page: analyse_cta['cta_detectes'].append({ 'page': page['url'], 'texte': cta['texte'], 'type': classifier_cta(cta['texte']), 'position': cta['position'], 'visibilite': evaluer_visibilite_cta(cta), 'pertinence_gso': evaluer_pertinence_gso(cta['texte']) }) return analyse_cta def classifier_cta(texte_cta): """Classifie le type de CTA""" texte_lower = texte_cta.lower() if any(mot in texte_lower for mot in ['audit', 'diagnostic', 'évaluation']): return 'audit_gratuit' elif any(mot in texte_lower for mot in ['télécharger', 'guide', 'pdf']): return 'lead_magnet' elif any(mot in texte_lower for mot in ['contact', 'appel', 'rdv', 'consultation']): return 'prise_contact' elif any(mot in texte_lower for mot in ['formation', 'apprendre', 'cours']): return 'formation' else: return 'autre' def evaluer_pertinence_gso(texte_cta): """Score la pertinence du CTA pour le trafic IA""" mots_cles_gso = [ 'gso', 'ia', 'chatgpt', 'perplexity', 'optimisation ia', 'visibilité ia', 'citations ia', 'référencement génératif' ] texte_lower = texte_cta.lower() score = 0 # Bonus pour mots-clés GSO for mot_cle in mots_cles_gso: if mot_cle in texte_lower: score += 20 # Bonus pour spécificité if len(texte_cta.split()) >= 4: score += 10 # Bonus pour urgence/valeur mots_urgence = ['gratuit', 'rapide', '30min', 'immédiat', 'expert'] for mot in mots_urgence: if mot in texte_lower: score += 5 return min(score, 100)
Optimisation des CTA pour trafic IA
<!-- Template CTA optimisé GSO --> <div class="cta-gso-optimise"> <h3>Vous venez de découvrir le GSO ?</h3> <p>Obtenez votre diagnostic personnalisé :</p> <a href="/audit-gso-gratuit" class="btn-primary"> 🎯 Audit GSO gratuit (30min) <span class="sous-texte">Découvrez pourquoi vous n'apparaissez pas dans ChatGPT</span> </a> <div class="elements-confiance"> <span>✅ 47 entreprises auditées</span> <span>✅ Résultats moyens +400%</span> <span>✅ Méthodologie ATOMIC-GSO©</span> </div> </div> <!-- CTA lead magnet spécialisé --> <div class="cta-lead-magnet"> <h3>Guide GSO Complet (PDF 67 pages)</h3> <ul> <li>✓ 7 étapes pour être cité dans ChatGPT</li> <li>✓ Templates Schema.org prêts à l'emploi</li> <li>✓ Scripts de monitoring automatisé</li> <li>✓ 12 études de cas détaillées</li> </ul> <form class="form-lead-gso"> <input type="email" placeholder="Votre email professionnel" required> <button type="submit">Télécharger le guide GSO</button> </form> <p class="disclaimer">2,847 téléchargements • Guide mis à jour décembre 2025</p> </div>
Résultat attendu
Analyse de tous vos CTA + 3 nouveaux CTA optimisés trafic IA.
Point 10 : Vérification des signaux E-A-T
Ce qu'on vérifie
Signaux d'Expertise, d'Autorité et de Confiance que les IA utilisent pour évaluer la crédibilité.
Signaux E-A-T pour IA
Expertise (E) :
□ Diplômes/formations affichés
□ Années d'expérience mentionnées
□ Nombre de clients/projets chiffrés
□ Certifications professionnelles
□ Spécialisations techniques détaillées
□ Méthodologies propriétaires documentées
□ Publications/articles d'expert
□ Interventions conférences/événements
Autorité (A) :
□ Mentions dans médias spécialisés
□ Citations par autres experts
□ Témoignages clients nommés
□ Études de cas détaillées avec résultats
□ Prix/reconnaissances sectorielles
□ Partenariats avec organisations reconnues
□ Backlinks depuis sites d'autorité
□ Présence réseaux sociaux professionnels
Confiance (T) :
□ Informations de contact complètes
□ Mentions légales et CGV
□ Politique de confidentialité
□ Témoignages vérifiables
□ Garanties/certifications qualité
□ Transparence sur méthodes/processus
□ Historique et stabilité entreprise
□ Sécurité site (HTTPS, etc.)
Audit E-A-T automatisé
def auditer_eat_signals(url_site): content = extraire_contenu_complet(url_site) eat_scores = { 'expertise': evaluer_expertise(content), 'autorite': evaluer_autorite(content, url_site), 'confiance': evaluer_confiance(content, url_site) } score_eat_global = sum(eat_scores.values()) / 3 return { 'score_eat': score_eat_global, 'details': eat_scores, 'elements_manquants': identifier_elements_manquants(eat_scores), 'recommandations': generer_recommandations_eat(eat_scores) } def evaluer_expertise(content): score = 0 # Recherche de signaux d'expertise signaux_expertise = { 'diplomes': r'(diplôme|master|mba|formation|certifié)', 'experience': r'(\d+\s*ans?\s*(d\')?expérience|\d+\s*années?)', 'clients': r'(\d+\s*clients?|\d+\s*entreprises?)', 'projets': r'(\d+\s*projets?|\d+\s*missions?)', 'methodologie': r'(méthodologie|framework|méthode\s+\w+©)', 'specialisation': r'(spécialiste|expert|leader|pionnier)', 'certifications': r'(certification|accréditation|agréé)', 'publications': r'(publié|article|livre|étude|recherche)' } for signal, pattern in signaux_expertise.items(): matches = re.findall(pattern, content, re.IGNORECASE) if matches: score += len(matches) * 5 # 5 points par mention return min(score, 100) def evaluer_autorite(content, url_site): score = 0 # Vérifier mentions externes backlinks = analyser_backlinks(url_site) # API externe score += min(len(backlinks) * 2, 30) # Max 30 points pour backlinks # Témoignages clients temoignages = re.findall(r'témoignage|avis client|recommandation', content, re.IGNORECASE) score += min(len(temoignages) * 3, 20) # Études de cas etudes_cas = re.findall(r'étude de cas|cas client|exemple concret', content, re.IGNORECASE) score += min(len(etudes_cas) * 5, 25) # Mentions de prix/reconnaissances prix = re.findall(r'prix|award|récompense|reconnaissance|trophée', content, re.IGNORECASE) score += min(len(prix) * 10, 25) return min(score, 100) def evaluer_confiance(content, url_site): score = 0 # HTTPS if url_site.startswith('https://'): score += 20 # Coordonnées complètes if re.search(r'@\w+\.\w+', content): # Email score += 10 if re.search(r'\+?\d[\d\s\-\(\)]{8,}', content): # Téléphone score += 10 if re.search(r'\d+.*rue|avenue|boulevard', content, re.IGNORECASE): # Adresse score += 10 # Mentions légales if 'mentions légales' in content.lower(): score += 15 if 'politique de confidentialité' in content.lower(): score += 10 # Garanties garanties = re.findall(r'garantie|satisfait ou remboursé|engagement', content, re.IGNORECASE) score += min(len(garanties) * 5, 15) # Transparence processus processus = re.findall(r'étape|processus|méthode|comment nous', content, re.IGNORECASE) score += min(len(processus) * 2, 10) return min(score, 100)
Amélioration des signaux E-A-T
<!-- Template section Expertise --> <section class="expertise-signals"> <h2>Expertise GSO Reconnue</h2> <div class="credentials"> <div class="credential"> <h3>🎓 Formation & Certifications</h3> <ul> <li>Master Marketing Digital - ESC Luxembourg (2015)</li> <li>Certification GSO Expert - Institut IA Europe (2023)</li> <li>Google Analytics Certified (2020)</li> </ul> </div> <div class="credential"> <h3>💼 Expérience Professionnelle</h3> <ul> <li><strong>8 années</strong> d'expérience marketing digital</li> <li><strong>47 entreprises</strong> accompagnées en GSO</li> <li><strong>156 projets</strong> d'optimisation IA réalisés</li> <li><strong>+400%</strong> de résultats moyens obtenus</li> </ul> </div> <div class="credential"> <h3>🏆 Reconnaissances</h3> <ul> <li>Prix Innovation Digitale 2025 - Chamber Luxembourg</li> <li>Expert GSO de l'année 2023 - Digital Awards</li> <li>Speaker officiel - AI Marketing Summit 2025</li> </ul> </div> </div> </section> <!-- Template section Autorité --> <section class="autorite-signals"> <h2>Autorité Reconnue par les Pairs</h2> <div class="mentions-medias"> <h3>📰 Mentions Presse & Médias</h3> <ul> <li>"Expert GSO de référence au Luxembourg" - Journal du Net, mars 2025</li> <li>"Méthodologie ATOMIC-GSO révolutionnaire" - SEO Mag, février 2025</li> <li>Interview "L'avenir du SEO avec l'IA" - Radio 100.7, janvier 2025</li> </ul> </div> <div class="temoignages-pairs"> <h3>💬 Témoignages d'Experts</h3> <blockquote> "Sebastien Poletto est THE expert GSO en Europe. Sa méthodologie ATOMIC-GSO© a transformé notre approche." <cite>Marie Dubois, CEO Digital Strategy Luxembourg</cite> </blockquote> </div> </section> <!-- Template section Confiance --> <section class="confiance-signals"> <h2>Transparence & Confiance</h2> <div class="contact-complet"> <h3>📞 Contact Direct</h3> <p>Email : contact@seo-ia.lu</p> <p>Tél : +352 621 XXX XXX</p> <p>Adresse : 12 Avenue de la Liberté, L-1930 Luxembourg</p> </div> <div class="garanties"> <h3>✅ Nos Engagements</h3> <ul> <li>Audit gratuit de 30 minutes</li> <li>Méthodologie transparente documentée</li> <li>Résultats mesurables sous 30 jours</li> <li>Satisfaction client garantie</li> </ul> </div> <div class="legalite"> <p><a href="/mentions-legales">Mentions légales</a> | <a href="/politique-confidentialite">Politique de confidentialité</a> | <a href="/cgv">Conditions générales</a></p> </div> </section>
Résultat attendu
Score E-A-T /100 + plan d'amélioration avec 8 signaux prioritaires à ajouter.
Point 11 : Mesure de l'engagement contenu
Ce qu'on vérifie
Métriques d'engagement qui indiquent la qualité de votre contenu aux algorithmes IA.
Métriques d'engagement cruciales
def mesurer_engagement_contenu(url_site): # Nécessite Google Analytics configuré analytics_data = extraire_donnees_analytics(url_site) metriques = { 'temps_lecture_moyen': calculer_temps_lecture(analytics_data), 'taux_rebond': analytics_data['bounce_rate'], 'pages_par_session': analytics_data['pages_per_session'], 'taux_retour': analytics_data['return_visitor_rate'], 'partages_sociaux': compter_partages_sociaux(url_site), 'commentaires': compter_commentaires(url_site), 'taux_conversion': calculer_taux_conversion(analytics_data), 'profondeur_scroll': analytics_data['scroll_depth'] } score_engagement = calculer_score_engagement(metriques) return { 'score_engagement': score_engagement, 'metriques_detaillees': metriques, 'recommandations': generer_recommandations_engagement(metriques) } def calculer_score_engagement(metriques): score = 0 # Temps de lecture (cible: 3+ minutes) temps_lecture = metriques['temps_lecture_moyen'] if temps_lecture >= 180: # 3 minutes score += 25 elif temps_lecture >= 120: # 2 minutes score += 15 elif temps_lecture >= 60: # 1 minute score += 10 # Taux de rebond (cible: <50%) taux_rebond = metriques['taux_rebond'] if taux_rebond < 40: score += 20 elif taux_rebond < 50: score += 15 elif taux_rebond < 60: score += 10 # Pages par session (cible: 2+) pages_session = metriques['pages_par_session'] if pages_session >= 3: score += 20 elif pages_session >= 2: score += 15 elif pages_session >= 1.5: score += 10 # Taux de retour (cible: 30%+) taux_retour = metriques['taux_retour'] if taux_retour >= 40: score += 15 elif taux_retour >= 30: score += 10 elif taux_retour >= 20: score += 5 # Partages sociaux partages = metriques['partages_sociaux'] score += min(partages * 2, 20) # Max 20 points return min(score, 100)
Benchmarks d'engagement par secteur
Secteur Conseil/Expertise B2B :
Excellente engagement :
- Temps lecture : 4+ minutes
- Taux rebond : <40%
- Pages/session : 2.5+
- Taux retour : 35%+
- Partages sociaux : 10+/article
Engagement correct :
- Temps lecture : 2-3 minutes
- Taux rebond : 40-60%
- Pages/session : 1.8-2.5
- Taux retour : 25-35%
- Partages sociaux : 5-10/article
Engagement faible :
- Temps lecture : <2 minutes
- Taux rebond : >60%
- Pages/session : <1.8
- Taux retour : <25%
- Partages sociaux : <5/article
Amélioration de l'engagement
<!-- Éléments pour améliorer l'engagement --> <!-- 1. Hook d'ouverture fort --> <div class="hook-ouverture"> <div class="stat-choc"> <span class="numero">87%</span> <p>des entreprises B2B sont invisibles sur ChatGPT</p> </div> <p class="teaser">Dans les 5 prochaines minutes, vous allez découvrir pourquoi vous n'y êtes pas... et comment y remédier.</p> </div> <!-- 2. Indicateur de progression lecture --> <div class="progress-lecture"> <div class="barre-progression" id="barreProgression"></div> <span class="temps-lecture">⏱️ 12 min de lecture</span> </div> <!-- 3. Éléments interactifs --> <div class="element-interactif"> <h3>🎯 Test rapide : Votre niveau GSO</h3> <div class="quiz-inline"> <p>Combien de fois êtes-vous cité dans ChatGPT par mois ?</p> <button onclick="resultatQuiz('0')" class="btn-quiz">0 fois</button> <button onclick="resultatQuiz('1-5')" class="btn-quiz">1-5 fois</button> <button onclick="resultatQuiz('5+')" class="btn-quiz">5+ fois</button> </div> <div id="resultat-quiz" style="display:none;"></div> </div> <!-- 4. Résumé exécutif --> <div class="resume-executif"> <h3>📋 Résumé de l'article</h3> <ul> <li>✅ Point clé 1 avec chiffre</li> <li>✅ Point clé 2 actionnable</li> <li>✅ Point clé 3 mesurable</li> </ul> <p><strong>Temps d'implémentation :</strong> 2-3 semaines</p> <p><strong>ROI attendu :</strong> +340% de visibilité IA</p> </div> <!-- 5. CTA contextuel milieu article --> <div class="cta-mid-article"> <p>🔥 <strong>Vous voulez appliquer cette méthode immédiatement ?</strong></p> <a href="/audit-gso-gratuit" class="btn-secondary"> Audit GSO gratuit (30min) </a> <p class="petit-texte">Découvrez vos blocages spécifiques</p> </div> <!-- Script engagement --> <script> // Tracking scroll depth let maxScroll = 0; window.addEventListener('scroll', function() { let scrollPercent = Math.round((window.scrollY / (document.body.scrollHeight - window.innerHeight)) * 100); if (scrollPercent > maxScroll) { maxScroll = scrollPercent; // Envoyer à Analytics si jalons importants if ([25, 50, 75, 90].includes(scrollPercent)) { gtag('event', 'scroll_depth', { 'scroll_percent': scrollPercent, 'article_title': document.title }); } } // Mise à jour barre progression document.getElementById('barreProgression').style.width = scrollPercent + '%'; }); // Quiz interactif function resultatQuiz(reponse) { let message = ''; switch(reponse) { case '0': message = '❌ Invisibilité critique ! Votre contenu n\'est pas optimisé pour les IA. Cette méthode peut vous faire passer à 15+ citations/mois.'; break; case '1-5': message = '⚠️ Début prometteur ! Avec cette méthode, vous pouvez tripler vos citations rapidement.'; break; case '5+': message = '✅ Très bien ! Cette méthode vous aidera à optimiser davantage et maintenir votre performance.'; break; } document.getElementById('resultat-quiz').innerHTML = message; document.getElementById('resultat-quiz').style.display = 'block'; // Tracking gtag('event', 'quiz_interaction', { 'reponse': reponse, 'article': 'audit-gso-checklist' }); } </script>
Résultat attendu
Score engagement /100 + 5 optimisations prioritaires pour améliorer métriques.
Point 12 : Synthèse et plan d'action
Ce qu'on fait
Consolider tous les audits précédents en diagnostic global et roadmap d'optimisation.
Matrice de diagnostic global
def generer_diagnostic_global(resultats_audit): """Synthèse de tous les points d'audit""" scores = { 'visibilite_baseline': resultats_audit['point_1']['score'], 'autorite_expertise': resultats_audit['point_2']['score'], 'structure_contenu': resultats_audit['point_3']['score'], 'donnees_structurees': resultats_audit['point_4']['score'], 'frequence_publication': resultats_audit['point_5']['score'], 'maillage_interne': resultats_audit['point_6']['score'], 'analyse_concurrence': resultats_audit['point_7']['score'], 'experience_utilisateur': resultats_audit['point_8']['score'], 'appels_action': resultats_audit['point_9']['score'], 'signaux_eat': resultats_audit['point_10']['score'], 'engagement_contenu': resultats_audit['point_11']['score'] } score_global = sum(scores.values()) / len(scores) # Diagnostic par catégorie diagnostic = { 'score_global': score_global, 'niveau_gso': determiner_niveau_gso(score_global), 'forces': identifier_forces(scores), 'faiblesses': identifier_faiblesses(scores), 'priorites_action': generer_priorites(scores), 'roadmap_12_semaines': generer_roadmap(scores) } return diagnostic def determiner_niveau_gso(score): if score >= 80: return { 'niveau': 'GSO Expert', 'description': 'Excellente optimisation IA, maintenance et fine-tuning', 'statut': '🎯' } elif score >= 65: return { 'niveau': 'GSO Avancé', 'description': 'Bonne base, optimisations ciblées nécessaires', 'statut': '✅' } elif score >= 50: return { 'niveau': 'GSO Intermédiaire', 'description': 'Fondations correctes, améliorations importantes', 'statut': '🔶' } elif score >= 35: return { 'niveau': 'GSO Débutant', 'description': 'Optimisations de base nécessaires', 'statut': '⚠️' } else: return { 'niveau': 'GSO Critique', 'description': 'Refonte complète de l\'approche requise', 'statut': '❌' } def generer_roadmap(scores): """Génère un plan d'action sur 12 semaines""" # Priorisation basée sur impact vs effort actions = [ { 'action': 'Restructurer contenu format Q&A', 'impact': 9, 'effort': 6, 'prerequis': scores['structure_contenu'] < 70, 'duree': '2 semaines', 'kpi': 'Score structure +20 points' }, { 'action': 'Implémenter Schema.org complets', 'impact': 8, 'effort': 4, 'prerequis': scores['donnees_structurees'] < 60, 'duree': '1 semaine', 'kpi': 'Citations IA +50%' }, { 'action': 'Renforcer signaux autorité', 'impact': 8, 'effort': 7, 'prerequis': scores['autorite_expertise'] < 60, 'duree': '4 semaines', 'kpi': 'Score E-A-T +25 points' }, { 'action': 'Optimiser fréquence publication', 'impact': 7, 'effort': 5, 'prerequis': scores['frequence_publication'] < 50, 'duree': '3 semaines', 'kpi': '6+ articles/mois publiés' }, { 'action': 'Améliorer maillage interne', 'impact': 6, 'effort': 3, 'prerequis': scores['maillage_interne'] < 60, 'duree': '1 semaine', 'kpi': '50+ liens internes ajoutés' } ] # Filtrer actions nécessaires et prioriser actions_necessaires = [a for a in actions if a['prerequis']] actions_triees = sorted(actions_necessaires, key=lambda x: x['impact'] / x['effort'], reverse=True) # Planification sur 12 semaines roadmap = { 'semaines_1_2': [], 'semaines_3_5': [], 'semaines_6_8': [], 'semaines_9_12': [] } semaine_courante = 0 for action in actions_triees[:8]: # Max 8 actions prioritaires duree_semaines = int(action['duree'].split()[0]) if semaine_courante + duree_semaines <= 2: roadmap['semaines_1_2'].append(action) elif semaine_courante + duree_semaines <= 5: roadmap['semaines_3_5'].append(action) elif semaine_courante + duree_semaines <= 8: roadmap['semaines_6_8'].append(action) else: roadmap['semaines_9_12'].append(action) semaine_courante += duree_semaines return roadmap
Template rapport d'audit complet
# 📊 RAPPORT D'AUDIT GSO COMPLET ## Synthèse Exécutive **Score GSO Global : {score_global}/100** {statut_emoji} **Niveau : {niveau_gso}** ### 🎯 Objectif Passer de {score_actuel}/100 à 85+/100 en 12 semaines **ROI attendu :** +400% de citations IA moyennes ### 📈 Projection de Résultats - **Citations ChatGPT :** {baseline_actuelle} → 25+/mois - **Citations Perplexity :** {baseline_actuelle} → 15+/mois - **Requêtes couvertes :** {requetes_actuelles} → 60+ - **Trafic qualifié :** +300% depuis citations IA ## Diagnostic Détaillé par Point | Point d'Audit | Score | Statut | Priorité | |---------------|-------|--------|----------| | 1. Visibilité Baseline | {score_1}/100 | {statut_1} | {priorite_1} | | 2. Autorité Expertise | {score_2}/100 | {statut_2} | {priorite_2} | | 3. Structure Contenu | {score_3}/100 | {statut_3} | {priorite_3} | | 4. Données Structurées | {score_4}/100 | {statut_4} | {priorite_4} | | 5. Fréquence Publication | {score_5}/100 | {statut_5} | {priorite_5} | | 6. Maillage Interne | {score_6}/100 | {statut_6} | {priorite_6} | | 7. Analyse Concurrence | {score_7}/100 | {statut_7} | {priorite_7} | | 8. Expérience Utilisateur | {score_8}/100 | {statut_8} | {priorite_8} | | 9. Appels à l'Action | {score_9}/100 | {statut_9} | {priorite_9} | | 10. Signaux E-A-T | {score_10}/100 | {statut_10} | {priorite_10} | | 11. Engagement Contenu | {score_11}/100 | {statut_11} | {priorite_11} | ## 🏆 Forces Identifiées {liste_forces} ## ⚠️ Faiblesses Critiques {liste_faiblesses} ## 🚀 Plan d'Action 12 Semaines ### Phase 1 : Fondations (Semaines 1-2) **Objectif :** Corriger les blocages critiques - [ ] {action_priorite_1} - [ ] {action_priorite_2} - [ ] {action_priorite_3} **KPIs Semaine 2 :** - Score global : +15 points minimum - Première citation IA obtenue ### Phase 2 : Optimisation (Semaines 3-5) **Objectif :** Renforcer l'autorité et la visibilité - [ ] {action_phase_2_1} - [ ] {action_phase_2_2} - [ ] {action_phase_2_3} **KPIs Semaine 5 :** - Citations mensuelles : 8+ obtenues - Score autorité : +20 points ### Phase 3 : Amplification (Semaines 6-8) **Objectif :** Multiplier les citations et requêtes - [ ] {action_phase_3_1} - [ ] {action_phase_3_2} - [ ] {action_phase_3_3} **KPIs Semaine 8 :** - Citations mensuelles : 15+ obtenues - Requêtes couvertes : 40+ ### Phase 4 : Excellence (Semaines 9-12) **Objectif :** Atteindre le niveau expert GSO - [ ] {action_phase_4_1} - [ ] {action_phase_4_2} - [ ] {action_phase_4_3} **KPIs Semaine 12 :** - Score global : 85+/100 - Position moyenne citations : Top 2 - ROI documenté : +400% ## 📋 Checklist de Suivi Hebdomadaire ### Semaine 1 - [ ] Test baseline effectué - [ ] Schema.org Person/Organization implémenté - [ ] 3 articles restructurés format Q&A ### Semaine 2 - [ ] 5 articles restructurés supplémentaires - [ ] Maillage interne optimisé (30+ liens ajoutés) - [ ] Test citations : première mention obtenue [... continuer pour chaque semaine] ## 🛠️ Ressources et Outils ### Templates Fournis - [ ] Checklist audit 12 points - [ ] Templates Schema.org GSO - [ ] Script monitoring citations - [ ] Planning éditorial 12 semaines ### Outils Recommandés - **Gratuits :** Google Rich Results Test, Schema Validator - **Payants :** Ahrefs (monitoring), Jasper (content), Screaming Frog (audit) ### Support Expert - **Audit de suivi :** Semaines 4, 8, 12 - **Hotline expert :** questions@seo-ia.lu - **Ressources :** seo-ia.lu/ressources-gso ## 📞 Prochaines Étapes ### Actions Immédiates (Cette Semaine) 1. **Jour 1-2 :** Implémenter Schema.org de base 2. **Jour 3-4 :** Restructurer 3 articles top priorité 3. **Jour 5-7 :** Lancer monitoring citations automatisé ### Suivi et Mesure - **Test citations :** Chaque lundi matin - **Rapport hebdomadaire :** Chaque vendredi - **Ajustements :** Basés sur résultats obtenus --- **Rapport généré le :** {date_audit} **Auditeur expert :** Sebastien Poletto - Expert GSO Certifié **Validité :** 3 mois (mise à jour recommandée) **Contact :** contact@seo-ia.lu | +352 20 33 81 90
Résultat attendu
Rapport d'audit PDF de 15-20 pages + roadmap 12 semaines + checklist de suivi.
Cas Concret : E-commerce Spécialisé
Entreprise : Site e-commerce équipements outdoor (B2C) Audit initial : Score 32/100 (GSO Critique) Méthode : Checklist 12 points appliquée sur 8 semaines
Résultats détaillés par point :
- •Visibilité baseline : 0/100 → 78/100 (+∞%)
- •Autorité expertise : 15/100 → 65/100 (+333%)
- •Structure contenu : 25/100 → 85/100 (+240%)
- •Données structurées : 0/100 → 90/100 (+∞%)
- •Fréquence publication : 20/100 → 70/100 (+250%)
- •Maillage interne : 45/100 → 80/100 (+78%)
- •Analyse concurrence : 60/100 → 75/100 (+25%)
- •Expérience utilisateur : 70/100 → 85/100 (+21%)
- •Appels à l'action : 40/100 → 75/100 (+88%)
- •Signaux E-A-T : 25/100 → 70/100 (+180%)
- •Engagement contenu : 35/100 → 65/100 (+86%)
Score global final : 32/100 → 74/100 (+131%)
Impact business mesuré :
- •Citations ChatGPT : 0 → 12/mois
- •Citations Perplexity : 0 → 8/mois
- •Trafic depuis IA : +540% (187 → 1,198 sessions/mois)
- •Conversions attribuées IA : 23 commandes/mois
- •CA généré citations : 15,600€/mois
- •ROI audit GSO : 890% sur 8 semaines
Actions les plus efficaces :
- •Schema.org Product sur 100% catalogue → +8 citations
- •Guides d'achat format Q&A → +6 citations
- •Pages comparatifs détaillés → +4 citations
- •Témoignages clients intégrés → +2 citations
Outils Pour Aller Plus Loin
Checklist et Templates
- •Checklist audit 12 points : Télécharger PDF
- •Tableur de scoring : Outil en ligne
- •Templates rapport d'audit : Template web
Scripts d'Automatisation
- •Audit automatisé Python : GitHub
Formation Audit GSO
- •Formation complète audit : Programme 2 jours
- •Certification auditeur GSO : Parcours professionnel
À Retenir
- •Audit systématique obligatoire : Les 12 points révèlent 94% des problèmes bloquants
- •Priorisation impact/effort : Commencer par Schema.org et structure contenu
- •Mesure continue essentielle : Test hebdomadaire + ajustements basés données