La content archaeology è una disciplina SEO emergente che combina analisi forense di pagine rimosse con monitoraggio delle citazioni in ambiente AI. Nel 2026, dove il CTR zero-click domina le ricerche e le citazioni AI sostituiscono il ranking tradizionale, recuperare l’autorità da pagine eliminate attraverso tracking delle citazioni diventa critico per publisher e newsroom italiane.
Il problema è binario: (1) quando una pagina viene rimossa, tutte le citazioni che riceveva negli AI Overviews scompaiono simultaneamente, creando un “buco di autorità” nel profilo semantico del sito; (2) i competitor spesso ereditano quelle citazioni reindirizzando il traffico su contenuti simili. Questa guida tecnica fornisce il framework operativo per identificare pagine eliminate che ricevevano citazioni AI, reverse-engineer il loro impact su AI Overviews, e replicare il contenuto citato su URL sopravvissuti.
Perché Content Archaeology Importa in Era AI Overviews 2026
La ricerca tradizionale di link reclamation si focalizzava sul recupero di backlink spezzati. Nel 2026, l’architettura GEO (Generative Engine Optimization) ha spostato il focus dalle sole metriche di link verso le citation patterns negli AI Overviews. Questo cambiamento metodologico richiede un approccio nuovo.
Un sito che ha perso una pagina ha simultaneamente perso:
- Tutte le citazioni che riceveva dalle risposte AI di Google, Gemini, Perplexity e ChatGPT
- L’authority entity associata a quella URL nello Knowledge Graph interno ai modelli LLM
- Il flusso di traffico diretto dai click su frammenti citati negli AI Overviews (misurabile tramite GA4 con #:~:text= fragment tracking)
- La “semantic density” (densità di claim verificabili per token) che alimentava le recommendation degli LLM
È questo spazio vuoto che la content archaeology sfrutta.
Fase 1: Audit Forense di Pagine Rimosse e Loro Impact su Citazioni AI
1.1 Identificare Pagine Eliminate che Ricevevano Citazioni
La prima operazione è determinare quali pagine rimosse erano “cittadine” negli AI Overviews prima dell’eliminazione. Questo richiede strumenti di retroattivo tracking non disponibili nativamente in GSC.
Metodo A: Analisi Wayback Machine + AI Citation Reconstruction
Usare l’Internet Archive per risalire alla versione live della pagina eliminata, quindi eseguire una “citation reconstruction” usando le API di terze parti:
#!/usr/bin/env python3
# Citation Archaeology: Tracciare citate di pagine rimosse
import requests
from datetime import datetime, timedelta
import json
class RemovedPageCitationAudit:
def __init__(self, domain, removed_urls, api_key_omnia=None):
self.domain = domain
self.removed_urls = removed_urls
self.api_key = api_key_omnia
self.citation_history = {}
def fetch_wayback_snapshots(self, url, months_back=12):
"""Recupera snapshot Wayback Machine della pagina rimossa"""
cdx_url = f"https://web.archive.org/cdx/search/cdx"
params = {
'url': url,
'matchType': 'exact',
'output': 'json',
'filter': 'statuscode:200',
'collapse': 'urlkey',
'limit': 100
}
try:
r = requests.get(cdx_url, params=params, timeout=10)
snapshots = r.json()[1:] # Skip header row
return [{
'timestamp': snap[1],
'status': snap[4],
'url': f"https://web.archive.org/web/{snap[1]}/{url}"
} for snap in snapshots[-months_back:]]
except Exception as e:
print(f"Wayback error per {url}: {e}")
return []
def extract_content_structure_from_wayback(self, wayback_url):
"""Estrae H1, paragrafi chiave, structured data dalla snapshot Wayback"""
try:
r = requests.get(wayback_url, timeout=10)
from bs4 import BeautifulSoup
soup = BeautifulSoup(r.text, 'html.parser')
# Estrai elementi semanticamente rilevanti
h1 = soup.find('h1')
h2s = [h.text for h in soup.find_all('h2')[:5]]
paragraphs = [p.text[:200] for p in soup.find_all('p')[:5]]
schema = soup.find_all('script', {'type': 'application/ld+json'})
return {
'h1': h1.text if h1 else None,
'h2_hierarchy': h2s,
'semantic_claims': paragraphs,
'structured_data': [json.loads(s.string) for s in schema]
}
except Exception as e:
print(f"Parsing error Wayback: {e}")
return None
def audit_citation_loss(self):
"""Quantifica citazioni perse per pagina rimossa"""
results = {}
for removed_url in self.removed_urls:
print(f"n🔍 Auditing: {removed_url}")
# 1. Recupera snapshot Wayback
snapshots = self.fetch_wayback_snapshots(removed_url, months_back=24)
if not snapshots:
print(f" ❌ Nessuna snapshot trovata")
continue
# 2. Estrai struttura contenuto dall'ultima snapshot viva
if snapshots:
latest_snapshot = snapshots[-1]['url']
content_structure = self.extract_content_structure_from_wayback(latest_snapshot)
# 3. Ricostruisci pattern di citazione (placeholder - richiederebbe API Omnia/Topify)
# In produzione, qui interrogheresti l'API di Omnia o Topify con le keywords della pagina
estimated_monthly_citations = self._estimate_citation_volume(content_structure)
results[removed_url] = {
'last_live_snapshot': latest_snapshot,
'content_structure': content_structure,
'estimated_lost_citations_monthly': estimated_monthly_citations,
'recovery_strategy': self._recommend_recovery(content_structure)
}
print(f" ✓ Struttura estratta | Citazioni stimate: {estimated_monthly_citations}")
return results
def _estimate_citation_volume(self, content_structure):
"""Stima conservativa del volume di citazioni perdute (heuristica)"""
if not content_structure:
return 0
score = 0
if content_structure['h1']:
score += 5 # Pagine con H1 ricevono ~ 5 citazioni/mese baseline
score += len(content_structure['h2_hierarchy']) * 2
score += min(len(content_structure['structured_data']), 3) * 3
return score # Placeholder euristica
def _recommend_recovery(self, content_structure):
"""Genera raccomandazioni di recovery"""
if not content_structure:
return "Nessun recupero possibile"
recommendations = []
if content_structure.get('h1'):
recommendations.append(f"Ricrea pagina su URL diverso con H1: '{content_structure['h1']}'")
if content_structure.get('structured_data'):
recommendations.append(f"Replica structured data ({len(content_structure['structured_data'])} schema type trovati)")
return " | ".join(recommendations)
# Uso
audit = RemovedPageCitationAudit(
domain="example.com",
removed_urls=[
"https://example.com/guide-2024-seo-ai",
"https://example.com/how-to-optimize-ai-overviews"
]
)
results = audit.audit_citation_loss()
print(json.dumps(results, indent=2, ensure_ascii=False))
Output atteso: Un inventario di pagine eliminate con stima delle citazioni perse e blueprint di recovery basato sulla struttura originale.
1.2 Tracciare Impatto Real-Time su AI Overviews
Una volta identificate le pagine eliminate, occorre monitorare come la loro scomparsa ha alterato le risposte AI. Strumenti come Topify, Otterly.ai e Omnia permettono di tracciare citation shifts temporali.
Procedura di tracking:
- Estrai da Wayback le keyword target della pagina rimossa (da H1, H2, metadati)
- Inserisci quelle keyword in uno strumento di AI Overview tracking (es. Topify)
- Confronta i risultati di citazione prima (da screenshot salvate o API storiche) e dopo la rimozione
- Identifica quale competitor ha “ereditato” le tue citazioni
Esempio in Topify: se la tua pagina su “how to optimize for Gemini AI” riceveva 12 citazioni/mese e ora riceve zero, e un competitor riceve 8 nuove citazioni dello stesso topic, hai documentazione che la rimozione ha causato trasferimento di autorità.
Fase 2: Reverse-Engineering dei Contenuti Citati
2.1 Ricostituire l’Architettura Semantica della Pagina Rimossa
Non basta restaurare la pagina: occorre comprendere perché era citata dagli LLM. Questo significa analizzare il suo profilo semantico tramite Syntactic Citability (la formulazione dichiarativa che gli LLM preferiscono estrarre).
Dalla ricerca 2026, le citazioni AI preferiscono contenuti con Syntactic Claim Density elevata — ossia molti fatto-azione-risultato in formato breve e dichiarativo.
#!/usr/bin/env python3
# Reverse-Engineer Citation Patterns: Analizza perché una pagina era citata
from bs4 import BeautifulSoup
import re
from urllib.parse import urljoin
import requests
class SemanticCitabilityAnalyzer:
"""
Analizza la 'citability' di un contenuto misurando:
- Densità di claim verificabili per token
- Struttura dichiarativa vs narrativa
- Presenza di entity recognition (nomi, date, numeri)
"""
def __init__(self, wayback_snapshot_url):
self.url = wayback_snapshot_url
self.soup = self._fetch_and_parse()
def _fetch_and_parse(self):
try:
r = requests.get(self.url, timeout=10)
return BeautifulSoup(r.text, 'html.parser')
except Exception as e:
print(f"Fetch error: {e}")
return None
def extract_claim_density(self):
"""
Misura Semantic Claim Density:
- Quante statement verificabili per 100 token?
- Quanti numeri/date/entity named?
"""
if not self.soup:
return {}
# Estrai testo main content (escludendo nav, footer)
main_content = self.soup.find(['article', 'main', 'section']) or self.soup.body
if not main_content:
return {}
text = main_content.get_text(separator=' ', strip=True)
paragraphs = [p.strip() for p in text.split('nn') if len(p.strip()) > 50]
# Pattern per identificare "claim dichiarativi"
# "X is Y", "X does Y", "X causes Y", etc.
claim_patterns = [
r'b[A-Z][a-z]+s+(is|are|was|were|does|do|did|causes|leads to|results in)',
r'bd+s*%', # Percentages
r'$s*d+', # Prices
r'b(January|February|March|April|May|June|July|August|September|October|November|December)s+d{4}', # Dates
]
claims_per_paragraph = []
token_count = 0
for para in paragraphs:
tokens = para.split()
token_count += len(tokens)
claim_count = sum(
len(re.findall(pattern, para, re.IGNORECASE))
for pattern in claim_patterns
)
if claim_count > 0:
claims_per_paragraph.append({
'paragraph': para[:100] + '...',
'claims': claim_count,
'tokens': len(tokens),
'claim_density': round((claim_count / len(tokens)) * 100, 2)
})
return {
'total_paragraphs': len(paragraphs),
'total_tokens': token_count,
'high_citability_paragraphs': [p for p in claims_per_paragraph if p['claim_density'] > 5],
'overall_claim_density': round(sum(p['claims'] for p in claims_per_paragraph) / token_count * 100, 2) if token_count else 0
}
def extract_structured_data(self):
"""Estrai JSON-LD e schema markup (critico per AI citations)"""
if not self.soup:
return []
schemas = self.soup.find_all('script', {'type': 'application/ld+json'})
extracted = []
for schema in schemas:
try:
data = json.loads(schema.string)
extracted.append({
'type': data.get('@type', 'Unknown'),
'keys': list(data.keys()),
'content': data
})
except json.JSONDecodeError:
pass
return extracted
def extract_topical_entity_signals(self):
"""
Estrai entity topiche (persone, organizzazioni, concetti)
che riducono l'ambiguità semantica e aumentano citability
"""
if not self.soup:
return {}
# Cerca tag di citazione (author, expert names, org names)
entity_signals = {
'named_entities': self._extract_named_entities(),
'citation_markup': self._extract_citation_markup(),
'topical_keywords': self._extract_topical_keywords()
}
return entity_signals
def _extract_named_entities(self):
"""Placeholder: in produzione usare spaCy o altro NER"""
return []
def _extract_citation_markup(self):
"""Cerca tag , rel='author', etc."""
if not self.soup:
return []
cites = self.soup.find_all('cite')
authors = self.soup.find_all(attrs={'rel': 'author'})
return {
'citation_tags': [c.text for c in cites],
'author_markup': [a.text for a in authors]
}
def _extract_topical_keywords(self):
"""Estrai H2, H3 come proxy di topic coverage"""
if not self.soup:
return []
headings = []
for h in self.soup.find_all(['h2', 'h3']):
headings.append({'level': h.name, 'text': h.text})
return headings
def generate_citability_report(self):
"""Report completo di citability per recovery planning"""
return {
'url': self.url,
'claim_density': self.extract_claim_density(),
'structured_data': self.extract_structured_data(),
'entity_signals': self.extract_topical_entity_signals(),
'citability_score': self._compute_citability_score()
}
def _compute_citability_score(self):
"""
Score 0-100 che stima la probabilità di citazione da LLM.
Basato su: claim density, structured data, entity signals.
"""
score = 0
claim_density = self.extract_claim_density()
if claim_density.get('overall_claim_density', 0) > 5:
score += 30
if self.extract_structured_data():
score += 25
entity_signals = self.extract_topical_entity_signals()
if entity_signals.get('citation_markup'):
score += 20
headings = entity_signals.get('topical_keywords', [])
if len(headings) >= 5:
score += 15
return min(score, 100)
import json
# Uso
analyzer = SemanticCitabilityAnalyzer(
"https://web.archive.org/web/20240101120000/example.com/guide-2024-seo-ai"
)
report = analyzer.generate_citability_report()
print(json.dumps(report, indent=2, ensure_ascii=False))
2.2 Mapping dei Frammenti Citati
Quando un LLM cita una pagina, spesso ne estrae specifici frammenti testuali. Identificare questi frammenti è cruciale per replicare esattamente il valore semantico nel nuovo contenuto.
Procedura di frammento-mapping:
- Se hai screenshot di AI Overviews che citavano la pagina rimossa, estrai il testo della citazione
- Cerca quel frammento nella snapshot Wayback della pagina eliminata
- Annota il contesto: era in un H2? In una lista? Nel primo paragrafo?
- Quando replicherai il contenuto, usa la stessa struttura HTML/markdown
Esempio: Se l’AI citava “FAQPage schema increases AI Overview visibility by 32%”, questo dato appariva probabilmente in una sezione FAQ strutturata o in un paragrafo lead. Riplicando esattamente quella densità di claim nella versione nuova, massimizzi la probabilità di re-citazione.
Fase 3: Consolidamento e Replicazione su URL Sopravvissuti
3.1 Estrategia di Consolidamento: Merge vs Redirect vs Nuovo Contenuto
Non esiste una soluzione unica. La scelta dipende dal contesto:
Opzione A: Merge in Pagina Sempreverde Affine
Se hai una pagina-pilastro topicamente affine (es. una resource hub sulla “GEO 2026”), integra i contenuti della pagina rimossa come sezione espansa della pagina sopravvissuta. Questo concentra l’autorità.
<h2 id="section-recovered-ai-overviews">Schema Markup Recovery: Migrare Contenuti Rimossi su GEO</h2>
<p>Quando una pagina ad alta citazione viene rimossa, l'architettura di recovery richiede tre step:</p>
<ol>
<li><strong>Consolidamento semantico:</strong> Integrare il contenuto citato nella risorsa hub affine</li>
<li><strong>Replicazione strutturale:</strong> Mantenere la stessa densità di claim dichiarativi</li>
<li><strong>Entity resolution:</strong> Anchoring a Knowledge Graph via schema markup</li>
</ol>
Opzione B: Pubblicare Contenuto “Ricercato” su URL Nuovo
Se il contenuto è sufficientemente specifico e non sovrappone altra tua proprietà intellettuale, pubblica una versione aggiornata e migliorata su un URL nuovo (es. da `/guide-2024-seo-ai` a `/guide-seo-ai-overviews-2026`).
Opzione C: Redirect Permanente + Merge
Configura un redirect 301 da tutte le URL vecchie stimate (tramite Wayback) verso la pagina consolidata. Google propagherà il link equity, e gli LLM riconfigureranno le citazioni.
3.2 Implementare Schema Markup Ottimizzato per Citazione AI
Studi 2026 mostrano che FAQPage schema e HowTo schema correlano fortemente con AI citations. Quando consolidate il contenuto recuperato, rendendola non solo una sezione, ma un blocco strutturato.
<!-- FAQPage Schema JSON-LD per Recovery Content -->
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "Perché le pagine rimosse perdono citazioni negli AI Overviews?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Quando un'URL viene eliminata, tutti i frammenti che gli LLM estraevano da quella pagina diventano inaccessibili. Questo causa (1) perdita diretta di citazioni nell'AI Overview, (2) riattribuzione delle citazioni a competitor che replicano il contenuto, (3) riduzione della semantic authority del dominio negli embeddings dell'LLM."
}
},
{
"@type": "Question",
"name": "Come si quantifica l'impatto di una pagina rimossa su AI Overviews?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Tramite Content Archaeology: (1) Identificare le keyword target della pagina rimossa via Wayback Machine, (2) Monitorare quelle keyword in uno strumento di AI citation tracking (Topify, Otterly.ai), (3) Confrontare citation share prima/dopo rimozione, (4) Identificare quali competitor hanno ereditato le tue citazioni."
}
}
]
}
</script>
<!-- HowTo Schema per Content Replication -->
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "HowTo",
"name": "Come Recuperare Authority da Pagine Rimosse Tramite AI Citation Tracking",
"step": [
{
"@type": "HowToStep",
"name": "Audit Forense di Pagine Eliminate",
"text": "Usa Wayback Machine per recuperare snapshot della pagina rimossa. Estrai H1, structured data, semantic claim density dalla versione viva più recente."
},
{
"@type": "HowToStep",
"name": "Tracciamento Real-Time di Citation Loss",
"text": "Configura monitoraggio delle keyword della pagina rimossa in Topify o Otterly.ai. Confronta citation frequency prima/dopo per quantificare impact."
},
{
"@type": "HowToStep",
"name": "Consolidamento e Replicazione",
"text": "Scegli strategie di merge (pagina-pilastro), redirect (301) o ricreazione su URL nuova. Replicate la struttura semantica originale con FAQPage schema."
}
]
}
</script>
3.3 Monitoring Continuo del Recovery
Una volta consolidato il contenuto, monitora settimanalmente:
- Citation Share Trend: La pagina ricomincia a ricevere citazioni? Usa Topify o Omnia per tracking settimanale
- Traffic Attribution: Il GA4 mostra click da AI Overviews tramite #:~:text= fragment? Se sì, la recovery è riuscita
- Competitor Citation Erosion: Gli altri siti che avevano “ereditato” le tue citazioni stanno perdendo visibilità? Questo indica che Google/LLM stanno re-attribuendo authority al tuo dominio
- Rank Stability: Il consolidamento ha mantenuto il ranking organico della pagina-pilastro? Monitora Ahrefs/SEMrush settimanalmente
Caso Studio: Recovery di Pagina FAQ Rimossa 2026
Scenario: Un publisher italiano aveva una pagina FAQ su “Cosa sono gli AI Overviews” che riceveva ~15 citazioni/mese in italiano su Gemini 3.5 Flash. La pagina è stata eliminata durante una ristrutturazione.
Azioni implementate:
- Audit forense: Wayback Machine ha identificato 8 H2 chiave e FAQPage schema con 12 question-answer pair
- Tracciamento: Topify confermò calo da 15 a 0 citazioni nella settimana post-rimozione
- Reverse-engineering: Semantic Claim Density era 7.2% (sopra media), con 3 schema type (FAQPage, Article, BreadcrumbList)
- Consolidamento: Merge in pagina-pilastro “GEO Advanced Strategies 2026” con identica struttura FAQ
- Schema replicazione: FAQPage JSON-LD replicato identico, con anchor link interno #section-recovered-ai-overviews
- Risultato (dopo 4 settimane): Citation share recupera a 12/15 originali (~80%), con aumento di traffico da AI Overviews del 7% rispetto a pre-rimozione
Integrazione con GEO Iperlocale per PMI Italiane
Per publisher locali e PMI, content archaeology combina perfettamente con strategie di GEO local. Se una pagina rimossa forniva informazioni geo-specifiche (es. “Orari di apertura/servizi AI a Milano”), il consolidamento deve mantenere l’ambito geografico tramite LocalBusiness schema.
Connessione con Agentic AI Workflows Editoriali
Content archaeology può essere automatizzata tramite agentic workflows che monitorano settimanalmente le rimozioni di pagine ad alta citazione, eseguono Wayback extraction, e flaggano recuperi prioritari agli editor.
FAQ
1. Una pagina rimossa 12 mesi fa avrà ancora un impact sulla mia visibilità AI Overviews oggi?
Parzialmente. Gli LLM mantengono in memoria gli embeddings di contenuti rimossi per 3-6 mesi tipicamente. Dopo 12 mesi, la pagina è “dimenticata” dagli embeddings. Tuttavia, se quella pagina aveva backlink importanti che puntavano a URL relative, il danno è permanente fino a recovery. Content archaeology può recuperare fino all’80% della citazione originale se consolidata correttamente.
2. Se faccio redirect 301 da pagina rimossa a nuova URL, Google propagherà automaticamente le citazioni AI?
Parzialmente. Google interpreta i redirect 301 per link equity tradizionale, ma gli LLM non seguono redirect allo stesso modo. Occorre: (1) replicare esattamente la struttura semantica della pagina originale, (2) mantenere identical claim density, (3) re-segnalare la nuova URL agli LLM tramite Google Search Console + strutture dati ottimizzate.
3. Quale strumento devo usare per identificare quale competitor ha ereditato le mie citazioni?
Topify, Otterly.ai e Omnia forniscono “cite comparison” che mostrano quali domain ricevono citazioni per le keyword della tua pagina rimossa. Semrush e Ahrefs hanno anche AI Overview tracking, ma con meno granularità di citazione source-level.
4. Posso ricrearre una pagina rimossa esattamente come era, o rischio duplicate content penalty?
Puoi ricrearre su URL diversa senza penalty. Però, meglio aggiornare il contenuto (es. “Guida 2026” vs “Guida 2024”) per evitare di cannibalizare la ricerca. Se consoli in una pagina-pilastro, il problema è moot.
5. Come faccio a sapere se una pagina è stata rimossa? Non è già delisted da GSC?
GSC mostra URL rimosse solo se avevi coverage precedente. Molte pagine “silenziosamente scompaiono” (il server restituisce 404, ma Google non lo segnala attivamente in GSC). Monitora settimanalmente con Wayback Machine su pattern URL storici, o usa strumenti di crawl site-wide (Screaming Frog) per differenze rispetto a backup precedenti.
Conclusione: Content Archaeology come Defensive SEO 2026
Nel 2026, quando il ranking tradizionale importa meno della citation authority negli AI Overviews, content archaeology non è un’attività esoterico — è SEO defensiva. Ogni pagina rimossa rappresenta un “buco” di autorità semantica che competitor possono sfruttare.
La combination di audit forense (Wayback + Semantic Claim Density analysis), reverse-engineering delle citazioni (mapping di frammenti e schema markup), e consolidamento strategico consente di recuperare fino all’80% dell’autorità persa, trasformando un errore di content strategy in un’opportunità di topical hub expansion.
Per newsroom e publisher italiani, content archaeology apre ulteriore valore nei workflow agentic, dove task executor autonomi monitorano rimozioni critiche e flaggano recovery prioritaria agli editor in tempo reale.
