Content Archaeology and Link Reclamation: Saving Authority from Removed Pages Via AI Citation Tracking — Reverse-Engineer Removal Impact on AI Overviews, Replicate Cited Content

Content Archaeology and Link Reclamation: Saving Authority from Removed Pages Via AI Citation Tracking — Reverse-Engineer Removal Impact on AI Overviews, Replicate Cited Content

La content archaeology It is an emerging SEO discipline that combines forensic analysis of removed pages with citation monitoring in an AI environment. In 2026, where Zero-click CTR dominates searches e AI citations replace traditional ranking, recovering authority from deleted pages through citation tracking is becoming critical for Italian publishers and newsrooms.

The problem is binary: (1) when a page is removed, all the citations it received in AI Overviews disappear simultaneously, creating an “authority gap” in the site's semantic profile; (2) competitors often inherit those citations by redirecting traffic to similar content. This technical guide provides the operational framework to identify deleted pages that received AI citations, reverse-engineer their impact on AI Overviews, and replicate the cited content on surviving URLs.

Why Content Archaeology Matters in the Era of AI Overviews 2026

Traditional link reclamation research focused on recovering broken backlinks. In 2026, GEO (Generative Engine Optimization) architecture shifted the focus away from link metrics alone toward citation patterns in the AI Overviews. This methodological change calls for a new approach.

A site that has lost a page has simultaneously lost:

  • All the quotes he received from the AI responses provided by Google, Gemini, Perplexity, and ChatGPT
  • The authority entity associated with that URL in the Knowledge Graph within LLM models
  • Traffic driven by clicks on snippets mentioned in AI Overviews (measurable via GA4 using #:~:text= snippet tracking)
  • The “semantic density” (density of verifiable claims per token) that powered LLM recommendations

It is this empty space that content archaeology exploits.

Phase 1: Forensic Audit of Removed Pages and Their Impact on AI Citations

1.1 Identify Deleted Pages That Were Cited

The first step is to determine which deleted pages were “local” in the AI Overviews prior to their deletion. This requires retroactive tracking tools that are not natively available in GSC.

Method A: Wayback Machine Analysis + AI Citation Reconstruction

Use the Internet Archive to find the live version of the deleted page, then perform a “citation reconstruction” using third-party APIs:

#!/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))

Expected output: An inventory of deleted pages, including an estimate of lost citations and a recovery plan based on the original structure.

1.2 Tracking Real-Time Impact on AI Overviews

Once the deleted pages have been identified, it is necessary to monitor how their removal has affected the AI responses. Tools such as Topify, Otterly.ai e Omnia allow us to track changes in citation patterns over time.

Tracking procedure:

  1. Extract the following from the Wayback Machine: target keyword from the removed page (from H1, H2, metadata)
  2. Insert those keywords into an AI Overview tracking tool (e.g., Topify)
  3. Compare citation results first (from saved screenshots or historical API data) and after the removal
  4. Identify which competitor has "inherited" your citations

Example on Topify: If your page on “how to optimize for Gemini AI” used to receive 12 citations per month and now receives zero, and a competitor receives 8 new citations on the same topic, you have evidence that the removal caused a transfer of authority.

Phase 2: Reverse Engineering of Cited Content

2.1 Reconstructing the Semantic Architecture of the Removed Page

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:

  1. Se hai screenshot di AI Overviews che citavano la pagina rimossa, estrai il testo della citazione
  2. Cerca quel frammento nella snapshot Wayback della pagina eliminata
  3. Annota il contesto: era in un H2? In una lista? Nel primo paragrafo?
  4. Quando replicherai il contenuto, usa la stessa struttura HTML/markdown

Example: 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: Migrating Removed Content to GEO</h2>
<p>When a high-citation page is removed, the recovery architecture requires three steps:</p>
<ol>
  <li><strong>Semantic consolidation:</strong> Integrate the cited content into the related hub resource</li>
  <li><strong>Structural replication:</strong> Maintain the same density of declarative claims</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:

  1. Audit forense: Wayback Machine ha identificato 8 H2 chiave e FAQPage schema con 12 question-answer pair
  2. Tracciamento: Topify confermò calo da 15 a 0 citazioni nella settimana post-rimozione
  3. Reverse-engineering: Semantic Claim Density era 7.2% (sopra media), con 3 schema type (FAQPage, Article, BreadcrumbList)
  4. Consolidamento: Merge in pagina-pilastro “GEO Advanced Strategies 2026” con identica struttura FAQ
  5. Schema replicazione: FAQPage JSON-LD replicato identico, con anchor link interno #section-recovered-ai-overviews
  6. 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

Integration with Hyper-Local GEO for Italian SMEs

For local publishers and SMEs, content archaeology combines perfectly with strategies local GEO. If a removed page provided geo-specific information (e.g., “Opening hours/AI services in Milan”), the consolidation must maintain the geographic scope using LocalBusiness schema.

Connection with Agentic AI Editorial Workflows

Content archaeology can be automated through agentic workflows that weekly monitor high-citation page removals, perform Wayback extraction, and flag priority recoveries to editors.

FAQ

1. Will a page removed 12 months ago still have an impact on my AI Overviews visibility today?

Partially. LLMs typically keep the embeddings of removed content in memory for 3–6 months. After 12 months, the page is “forgotten” by the embeddings. However, if that page had important backlinks pointing to related URLs, the damage is permanent until recovery. Content archaeology can recover up to 80% of the original citation if properly consolidated.

2. If I do a 301 redirect from a removed page to a new URL, will Google automatically propagate the AI citations?

Partially. Google interprets 301 redirects for traditional link equity, but LLMs do not follow redirects in the same way. It is necessary to: (1) exactly replicate the semantic structure of the original page, (2) maintain identical claim density, (3) re-signal the new URL to LLMs via Google Search Console + optimized structured data.

3. Which tool should I use to identify which competitor has inherited my citations?

Topify, Otterly.ai, and Omnia provide “cite comparison” features that show which domains receive citations for your removed page's keywords. Semrush and Ahrefs also feature AI Overview tracking, but with less source-level citation granularity.

4. Can I recreate a removed page exactly as it was, or do I risk a duplicate content penalty?

You can recreate on a different URL without penalty. However, it is better to update the content (e.g., “2026 Guide” vs “2024 Guide”) to avoid cannibalizing the search. If you consolidate into a pillar page, the problem is moot.

5. How do I know if a page has been removed? Isn't it already delisted from GSC?

GSC only shows removed URLs if you had previous coverage. Many pages “silently disappear” (the server returns a 404, but Google doesn't actively report it in GSC). Monitor weekly with the Wayback Machine on historical URL patterns, or use site-wide crawl tools (Screaming Frog) for differences compared to previous backups.

Conclusion: Content Archaeology as Defensive SEO 2026

In 2026, when Traditional ranking matters less than citation authority in AI Overviews, content archaeology is not an esoteric activity — it is Defensive SEO. Each removed page represents a semantic authority “hole” that competitors can exploit.

The combination of forensic auditing (Wayback + Semantic Claim Density analysis), citation reverse engineering (mapping of fragments and schema markup), and strategic consolidation makes it possible to recover up to 80% of lost authority, transforming a content strategy error into an opportunity for topical hub expansion.

For Italian newsrooms and publishers, content archaeology unlocks additional value in agentic workflow, where autonomous task executors monitor critical removals and flag priority recovery to editors in real time.

Picture of Dario

Dario

All articles →

Related articles