Hoe je massaal LinkedIn-connectieverzoeken intrekt (oudste eerst) in 2025

Heb je ooit die gevreesde limiet voor LinkedIn-connectieverzoeken bereikt? Het voelt alsof je probeert te netwerken op een feestje waar de uitsmijter plotseling zegt: "Genoeg handen geschud voor vandaag."

LinkedIn beperkt je openstaande uitnodigingen tot 500. Zodra je die drempel bereikt, loopt je netwerkmomentum tegen een muur aan. Wat het bijzonder frustrerend maakt, is dat oude connectieverzoeken daar gewoon blijven liggen en digitaal stof verzamelen.

Niemand vertelt je dit wanneer je begint met het opbouwen van je netwerk, maar het beheren van je openstaande uitnodigingen is cruciaal voor het behouden van een gezonde LinkedIn-aanwezigheid.

Waarom je je openstaande uitnodigingen moet opschonen

De limiet van 500 uitnodigingen is geen willekeurig getal. LinkedIn gebruikt dit als onderdeel van de manier waarop accounts worden beoordeeld:

1. Impact op het algoritme: LinkedIn's algoritme beschouwt accounts die constant tegen deze limiet aanlopen als mogelijk verdacht, wat je bereik en zichtbaarheid kan verminderen

2. Verse connecties zijn belangrijk: Die recente connectieverzoeken die je naar hete prospects hebt gestuurd? Die worden mogelijk nooit geaccepteerd als je wachtrij verstopt zit met openstaande uitnodigingen van 6 maanden oud

3. Kwaliteit van je netwerk: Een opgeblazen lijst met openstaande verzoeken is als een overvolle inbox - het wordt steeds moeilijker om bij te houden wie belangrijk is

Helaas kon ik geen oplossing vinden die niet ALLE openstaande uitnodigingen zonder onderscheid wegblies. Dat verse connectieverzoek dat je gisteren naar een potentiële klant stuurde? Weg, samen met die willekeurige uit 2022.

De slimme manier: Trek de oudste uitnodigingen eerst in

Aangezien wij de LinkedIn-experts zijn (niet om op te scheppen natuurlijk), hebben we dit script geschreven dat zich eerst richt op je oudste openstaande verzoeken, zodat je precies kunt bepalen hoeveel je wilt intrekken.

Dit script:

• Sorteert alle openstaande uitnodigingen op leeftijd

• Verwerkt de oudste eerst

• Laat je exact instellen hoeveel uitnodigingen je wilt intrekken

• Bevat een vertraging tussen acties om LinkedIn's automatiseringsdetectie niet te activeren

Hoe je het script gebruikt (stap voor stap)

1. Navigeer naar je pagina met verzonden uitnodigingen

Ga eerst naar je pagina met verzonden LinkedIn-uitnodigingen:

• Ga naar "Mijn netwerk" in de LinkedIn-navigatie

• Klik op "Alles bekijken" naast "Uitnodigingen"

• Klik op het tabblad "Verzonden"

Of gebruik gewoon deze directe link: https://www.linkedin.com/mynetwork/invitation-manager/sent/

2. Open de Developer Console van je browser

Klik met de rechtermuisknop ergens op de pagina en selecteer "Inspecteren" of "Element inspecteren" (de bewoording varieert per browser).

Klik vervolgens op het tabblad "Console" in het paneel met ontwikkelaarstools dat wordt geopend.

Het hoort er ongeveer zo uit te zien:

3. Configureer en plak het script

Kopieer onderstaand script:

/*
Developed by: LiGo Team
Modified by: You can put your name here
Original Source: https://ligosocial.com/blog/how-to-mass-withdraw-linkedin-connection-requests
You are free to use this script anywhere with proper credit to the original source.
*/

(function() {
    // Configuration
    const max_limit = 10; // Set the number of invitations to withdraw (or undefined for all)
    const delay_between_withdrawals = 5000; // Time to wait between withdrawals in milliseconds (5 seconds)
    
    // Function to get all invitation elements
    const getInvitations = () => {
        const withdrawInvitationContainers = document.querySelectorAll("div.invitation-card__action-container");
        return Array.from(withdrawInvitationContainers);
    };
    
    // Function to get the date from invitation card
    const getInvitationDate = (invitationCard) => {
        // Navigate up to find the parent invitation card
        const card = invitationCard.closest('.invitation-card');
        if (!card) return new Date(0); // Default to oldest possible date if can't find
        
        // Look for date text (typically shows as "Sent 2 weeks ago" or similar)
        const dateText = card.querySelector('.time-badge, .invitation-card__time-ago');
        if (!dateText || !dateText.textContent) return new Date(0);
        
        const timeText = dateText.textContent.trim();
        const now = new Date();
        
        // Parse relative time text
        if (timeText.includes('second')) {
            return new Date(now - parseInt(timeText.match(/\d+/) || '0') * 1000);
        } else if (timeText.includes('minute')) {
            return new Date(now - parseInt(timeText.match(/\d+/) || '0') * 60 * 1000);
        } else if (timeText.includes('hour')) {
            return new Date(now - parseInt(timeText.match(/\d+/) || '0') * 60 * 60 * 1000);
        } else if (timeText.includes('day')) {
            return new Date(now - parseInt(timeText.match(/\d+/) || '0') * 24 * 60 * 60 * 1000);
        } else if (timeText.includes('week')) {
            return new Date(now - parseInt(timeText.match(/\d+/) || '0') * 7 * 24 * 60 * 60 * 1000);
        } else if (timeText.includes('month')) {
            return new Date(now - parseInt(timeText.match(/\d+/) || '0') * 30 * 24 * 60 * 60 * 1000);
        } else if (timeText.includes('year')) {
            return new Date(now - parseInt(timeText.match(/\d+/) || '0') * 365 * 24 * 60 * 60 * 1000);
        }
        
        return new Date(0); // Default to oldest if can't parse
    };
    
    // Main function to remove invitations
    const removeInvitations = async () => {
        console.log("🔍 Getting all invitations...");
        let invitations = getInvitations();
        
        // Sort invitations by date (oldest first)
        console.log("⏱️ Sorting invitations by age (oldest first)...");
        invitations.sort((a, b) => {
            const dateA = getInvitationDate(a);
            const dateB = getInvitationDate(b);
            return dateA - dateB; // Ascending order (oldest first)
        });
        
        // Limit the number if specified
        if (max_limit !== undefined && invitations.length > max_limit) {
            invitations = invitations.slice(0, max_limit);
            console.log(`⚙️ Will withdraw ${max_limit} oldest invitations`);
        } else {
            console.log(`⚙️ Will withdraw all ${invitations.length} invitations (oldest first)`);
        }
        
        // Start withdrawing
        let counter = 0;
        for (let invitation of invitations) {
            const actionButton = invitation.querySelector('button.invitation-card__action-btn');
            if (!actionButton) continue;
            
            // Get the invitation info for logging
            const card = invitation.closest('.invitation-card');
            const nameElement = card?.querySelector('.invitation-card__title');
            const name = nameElement ? nameElement.textContent.trim() : "Unknown connection";
            
            console.log(`🔄 Withdrawing invitation ${counter + 1}/${invitations.length}: ${name}`);
            
            // Click the withdraw button and confirm
            await new Promise((resolve) => {
                actionButton.click();
                
                const intervalId = setInterval(() => {
                    const confirmButton = document.querySelector('[data-test-modal-container] > [data-test-modal] [data-test-dialog-primary-btn]');
                    if (confirmButton) {
                        clearInterval(intervalId);
                        confirmButton.click();
                        console.log(`✅ Withdrawn invitation to ${name}`);
                        setTimeout(resolve, delay_between_withdrawals);
                    }
                }, 100);
            });
            
            counter++;
        }
        
        console.log(`-----------------------Withdraw invitation script completed-----------------------`);
        console.log(`-----------------------${counter} pending invitations withdrawn-------------------------------`);
    };
    
    // Run the script
    console.log("▶️ Starting LinkedIn invitation withdrawal script (oldest first)...");
    removeInvitations();
})();

Belangrijk: Pas voor het plakken de waarde max_limit in het script aan om aan te geven hoeveel uitnodigingen je wilt intrekken. De standaardwaarde staat op 10.

Als je in Chrome een bericht "plakken is geblokkeerd" krijgt, typ dan "allow pasting" in de console en druk op Enter, en probeer het daarna opnieuw te plakken.

4. Voer het script uit

Druk na het plakken van het script op Enter om het uit te voeren. Je ziet voortgangsupdates in de console terwijl elke uitnodiging wordt ingetrokken.

Het script zal:

1. Al je openstaande uitnodigingen vinden

2. Ze sorteren op leeftijd (oudste eerst)

3. Het opgegeven aantal oudste uitnodigingen intrekken

4. De voortgang in realtime tonen

Tips voor optimale resultaten

• Begin klein: Test eerst met 5-10 uitnodigingen om te zien hoe het werkt

• Overdrijf niet: LinkedIn kan overmatige automatisering markeren, dus trek niet honderden tegelijk in

• Pas de vertraging aan: Als je problemen ondervindt, probeer dan de waarde delay_between_withdrawals te verhogen voor meer ruimte tussen acties

• Compatibiliteit met meerdere browsers: Dit script zou moeten werken in Chrome, Firefox, Edge en andere grote browsers

• Controleer de resultaten: Controleer het aantal verzonden uitnodigingen voor en na om te bevestigen dat het intrekken is gelukt

FAQ

Is er een manier om te zien wie mijn uitnodigingen niet heeft geaccepteerd?

Ja! Dat is precies wat de pagina met verzonden uitnodigingen je laat zien. Navigeer naar linkedin.com/mynetwork/invitation-manager/sent/ om al je openstaande verzoeken te bekijken.

Weten mensen het als ik mijn uitnodiging intrek?

Nee, LinkedIn stelt gebruikers niet op de hoogte wanneer je een connectieverzoek intrekt. Ze zien de uitnodiging gewoon niet meer in hun lijst met openstaande verzoeken.

Hoeveel connectieverzoeken kan ik tegelijk in behandeling hebben?

LinkedIn beperkt gebruikers tot 500 openstaande uitnodigingen op enig moment. Zodra je deze limiet bereikt, moet je oude uitnodigingen intrekken voordat je nieuwe kunt verzenden.

Kan ik gestraft worden voor het gebruik van dit script?

Dit script bootst natuurlijk menselijk gedrag na door vertragingen tussen acties op te nemen. Gebruik het echter verantwoord - trek geen honderden uitnodigingen in snelle opeenvolging in, omdat dit mogelijk LinkedIn's automatiseringsdetectie kan activeren.

Maakt het intrekken van uitnodigingen mijn wekelijkse uitnodigingslimiet vrij?

Nee, het intrekken van uitnodigingen reset je wekelijkse uitnodigingslimiet niet (die staat los van de openstaande limiet). Het maakt alleen ruimte vrij in je wachtrij met openstaande uitnodigingen.

Stroomlijn je volledige LinkedIn-strategie

Het beheren van openstaande uitnodigingen is slechts één onderdeel van een effectieve LinkedIn-aanwezigheid. Als je freelancer, consultant of bureau-eigenaar bent die meerdere klantaccounts jongleert, weet je hoe tijdrovend contentcreatie en engagement kunnen zijn.

Dat is waar LiGo om de hoek komt kijken. Ons AI-aangedreven platform helpt je:

• Boeiende LinkedIn-content te genereren op basis van je expertise

• Meerdere klantstemmen te beheren met onderscheidende contentthema's

• Intelligente reacties te creëren die engagement stimuleren

• Je LinkedIn-prestaties te analyseren met gedetailleerde analytics

LiGo is speciaal ontworpen voor drukke professionals die de waarde van LinkedIn begrijpen, maar geen uren hebben om te besteden aan het schrijven van de perfecte berichten.

Gerelateerde bronnen

Wil je meer leren over het optimaliseren van je LinkedIn-strategie? Bekijk deze gerelateerde artikelen:

• Wat gebeurt er als ik een LinkedIn-uitnodiging intrek?

• Zijn er beperkingen aan het aantal LinkedIn-uitnodigingen dat ik kan verzenden?

• Hoe je je verzonden uitnodigingen op LinkedIn bekijkt

• Tips om LinkedIn's wekelijkse uitnodigingslimiet te omzeilen

Laatst bijgewerkt: 26 februari 2025