XML-sitemap: handleiding 

Een XML-sitemap functioneert als de routekaart om zoekmachines te vertellen welke content beschikbaar is en hoe deze URLs te bereiken zijn.

Om een ​​beter begrip te krijgen van XML-sitemaps en hoe jij ze efficiënt kunt gebruiken, helpt het om te weten wat de voordelen zijn van een XML-sitemap en hoe je een goede sitemap instelt.

Wat zijn XML-sitemaps?

In zijn eenvoudigste vorm dient een sitemap als een routekaart voor zoekmachines om de belangrijkste content van een website te begrijpen en meer context te krijgen over de algemene structuur van uw website. Naast het bieden van een lijst met URL's aan zoekmachines, kunnen sitemaps zoekmachines helpen nieuwere content te vinden, of content die zich diep in de architectuur van de website bevindt, wat websites met een slechte interne linkstructuur kunt helpen.

Veelvoorkomende mythen over XML-sitemaps:

1. Een sitemap is geen lijst van de pagina's op de website. Het is niet nodig om elke pagina in de sitemap op te nemen. De meeste websites bevatten gevoelige content, zoals informatie over investeerders, of content die geen goede gebruikerservaring biedt via de zoekfunctie, zoals aanmeldings- of accountpagina's, en content achter betaalmuren of pagina's die een 301-redirect status retourneren. Dit zijn voorbeelden van pagina's die niet beschikbaar moeten zijn voor zoekmachines en die niet in een sitemap kunnen worden opgenomen.
2. Sitemaps zijn niet nodig als mijn website goed is ingedeeld. Hoewel een goede infrastructuur altijd belangrijk is, is een XML-sitemap bedoeld om te dienen als indicator van de belangrijkste content die jij wilt laten crawlen en in aanmerking wilt laten komen voor indexering. Aangezien de zoekmachines werken met crawlbudgetten, kan dit een voordelige aanpak zijn voor grotere websites. Als een website meer dan 50.000 URL's heeft, kan het maken van een sitemapindex die meerdere sitemaps bevat, de beste keuze zijn.
3. Sitemaps vertellen Google wat te indexeren. Een XML-sitemap garandeert niet dat een pagina wordt geïndexeerd, alleen dat deze in aanmerking komt voor indexering.

Negeer de tags 'prioriteit' en 'frequentie wijzigen'

Twee populaire markeringen in XML-sitemaps zijn de tags 'priority' en 'change frequency'. Veel webmasters gebruiken deze opmaak om de efficiëntie van het crawlen te verbeteren en de prioriteitsinhoud van een website te benadrukken. John Mueller van Google heeft verklaard dat Google deze twee signalen negeert. Hij heeft echter aangegeven dat het gebruik van de lastmod-markering wordt gebruikt wanneer Google een sitemap analyseert. Door op deze tag te concentreren en ervoor te zorgen dat jij de juiste URL's opneemt, kun jij er zeker van zijn dat een sitemap efficiënt wordt gecrawld en de grootste impact heeft.

Maak een sitemap beschikbaar voor de zoekmachines

De eerste stap om ervoor te zorgen dat belangrijke content wordt ontdekt, is leren hoe jij een sitemap kunt maken en deze in de hoofdmap van de server kunt plaatsen.

Zorg er vervolgens voor dat jij een link naar de XML-sitemap opgeeft in de robots.txt-bestand. Dit bestand is een van de eerste plaatsen die een bot van een zoekmachine bezoekt wanneer deze een website bezoekt. Daar vindt men richtlijnen over welke content moet worden gecrawld en welke content moet worden vermeden. Door een link naar een sitemap op te nemen, help jij ervoor te zorgen dat zoekmachines de content crawlen.

Een laatste stap is om de sitemap fysiek in te dienen bij Google Search Console en Bing Webmaster Tools. Volgens het webmasterforum van Google controleren ze je sitemap niet elke keer dat deze wordt bijgewerkt, alleen de eerste keer dat ze het opmerken. Daarna zullen ze de sitemap alleen controleren als ze op de hoogte zijn gebracht dat deze is gewijzigd. Dit kan worden gedaan met behulp van de sitemap-tool van Google Search Console en met behulp van de "ping"-functionaliteit om Google te vragen de sitemap te crawlen door een HTTP GET-verzoek te verzenden:

http://www.google.nl/ping?sitemap=<complete_url_sitemap>

Neem alleen geldige URL's op

Het is absoluut noodzakelijk dat een sitemap verwijst naar URL's die kunnen worden geïndexeerd en een 200 status retourneren. Webmasters, SEO's of developers moeten routinematig de sitemap van hun website controleren om pagina's te verwijderen die 404-fouten, 300 status en 500 serverfouten retourneren.

Dit kan handmatig worden gedaan door de sitemap te crawlen of door het XML-sitemaprapport van Google Search Console te gebruiken om ongeldige URL's te identificeren. Onthoud dat zoekmachines werken met een crawlbudget, dus elke niet-indexeerbare URL vergroot de kans dat een geldige URL niet wordt gecrawld.

Gebruik consistente, gekwalificeerde URL's

Consistentie is belangrijk voor een correct opgemaakte XML-sitemap. Zorg ervoor dat er consistente protocollen worden gebruikt. Als een website een beveiligde website is (gebruikt HTTPS), zorg er dan voor dat de sitemap en alle URL's het beveiligde protocol gebruiken. Anders bevat een sitemap omleidingen die de crawlefficiëntie en indexering kunnen beïnvloeden.

Gebruik consistente subdomeinen. Aangezien de XML-sitemap inzicht geeft in de architectuur en organisatie van de website, zou elk subdomein zijn eigen sitemap moeten hebben. Dit helpt ook om uw sitemaps zo compact mogelijk te houden.

Voeg unieke URL's toe

Zorg ervoor dat je alleen canonieke versies van URL's opneemt. URL's die parameters of sessie-ID's bevatten, kunnen als dubbel worden beschouwd en moeten worden uitgesloten. Anders kunnen de crawlefficiëntie en de algehele indexering eronder lijden.

Zorg er bij het uitvoeren van regelmatige sitemap-audits voor dat je zoekt naar niet-canonieke URL's en verwijder deze. Nogmaals, het gebruik van het sitemaprapport van Google Search Console kan jou helpen om niet-canonieke URL's gemakkelijk te identificeren en het is een goede gewoonte om dit rapport regelmatig te controleren.

Voeg geen niet-alfanumerieke tekens toe

Een sitemap moet UTF-8-gecodeerd zijn. URL's moeten escapecodes voor entiteiten gebruiken voor tekens zoals ampersands (&), enkele aanhalingstekens ('), dubbele aanhalingstekens ("), kleiner dan (<) en groter dan (>). Bovendien mogen URL's alleen ASCII-tekens bevatten.

Beperk de grootte van de sitemap

De grootte van een XML-sitemap kan snel uit de hand lopen, vooral voor grotere websites zoals e-commercesites. Wanneer een sitemap te groot wordt, kan dit een negatieve invloed hebben op het aantal URL's dat wordt gecrawld en geïndexeerd, en het kan ertoe bijdragen dat de webserver vastloopt als deze grote bestanden moet verwerken. Om dit tegen te gaan, moeten XML-sitemaps worden beperkt tot 50.000 URL's en/of niet groter zijn dan 50 MB. Dit betekent dat grotere websites mogelijk meerdere sitemaps moeten gebruiken in een sitemapindexbestand.

Voor grotere sitemaps kan het uitsplitsen van inhoudssecties in hun eigen sitemaps helpen om de content georganiseerd te houden en sitemap-bloat te voorkomen. Heb je enorm veel afbeeldingen, pagina’s, video’s en blogs? Dan kun je ook nog onderscheid maken tussen en aparte sitemaps laten genereren op basis van pagina’s, afbeeldingen, et cetera.

Kijk naar de inlinks per XML-sitemap

1. Plaats het onderstaande script in een Google App script. Open een Google spreadsheet -> ga naar Uitbreidingen -> Apps scripts.
2. Kopieer en plak de onderstaande functie in A2 en druk op Enter: =EXTRACT_SITEMAP(A1)
3. Je bent nu geslaagd om alle genestelde sitemaps uit kolom A te parsen.
4. Kopieer en plak de onderstaande functie in B2 (tegen elke sitemap-URL) en druk op enter: =COUNTA(EXTRACT_SITEMAP(B2))
5. De bovenstaande functie haalt alle <loc> URL's uit de sitemap en telt ze bij elkaar op.

function EXTRACT_SITEMAP(sitemapUrl) {
  try {

    var xml = UrlFetchApp.fetch(sitemapUrl,{muteHttpExceptions:true});
    var document = XmlService.parse(xml.getContentText());
    var root = document.getRootElement()
    var namespace = root.getNamespace().getURI()
    var sitemapNameSpace = XmlService.getNamespace(namespace);
    let urls = root.getChildren('url',sitemapNameSpace)[0] ? root.getChildren('url', sitemapNameSpace) : root.getChildren('sitemap', sitemapNameSpace);
    var locs = []
   
    for (var i=0;i <urls.length;i++) {
      locs.push(urls[i].getChild('loc', sitemapNameSpace).getText())
    }
   
    return locs  
  } catch (e) {
    console.log(e)
    if (e.toString().includes("The markup in the document preceding the root element must be well-formed")) return "Parsing error: is this a valid XML sitemap?";
    return e.toString()
  }
}