How to Mass Withdraw LinkedIn Connection Requests (Oldest First) in 2025

Ever hit that dreaded LinkedIn connection request limit? It's like trying to network at a party where the bouncer suddenly tells you, "That's enough handshakes for today."

LinkedIn caps your pending invitations at 500. Once you reach that threshold, your networking momentum hits a wall. But what makes this especially frustrating is when old connection requests are just sitting there, collecting digital dust.

Nobody tells you this when you start building your network, but managing your pending invitations is critical for maintaining a healthy LinkedIn presence.

Why You Need to Clean Up Your Pending Invitations

The 500-invitation limit isn't just an arbitrary number. LinkedIn uses it as part of how they evaluate accounts:

1. Algorithm Impact: LinkedIn's algorithm views accounts that constantly hit this limit as potentially suspicious, potentially reducing your reach and visibility

2. Fresh Connections Matter: Those recent connection requests you sent to hot prospects? They might never get accepted if your queue is clogged with 6-month-old pending invites

3. Network Quality: A bloated pending list is like having an overflowing inbox-it gets harder to track who's important

Unfortunately, I couldn't find a solution that didn't blast through ALL your pending invitations without discrimination. That fresh connection request you sent yesterday to a potential client? Gone along with that random one from 2022.

The Smart Way: Withdraw Oldest Invitations First

Being the Linkedin experts that we are (not to brag or anything, of course), we wrote this script that targets your oldest pending requests first, letting you precisely control how many to withdraw.

This script:

• Sorts all pending invitations by age

• Processes the oldest ones first

• Allows you to set exactly how many invitations to withdraw

• Includes a delay between actions to avoid triggering LinkedIn's automation detection

How to Use the Script (Step-by-Step)

1. Navigate to Your Sent Invitations Page

First, go to your sent LinkedIn invitations page:

• Go to "My Network" in the LinkedIn navigation

• Click "See all" next to "Invitations"

• Click the "Sent" tab

Or simply use this direct link: https://www.linkedin.com/mynetwork/invitation-manager/sent/

2. Open Your Browser's Developer Console

Right-click anywhere on the page and select "Inspect" or "Inspect Element" (the wording varies by browser).

Then click on the "Console" tab in the developer tools panel that opens.

It's kinda supposed to look like this:

3. Configure and Paste the Script

Copy the script below:

/*
Developed by: LiGo Team
Modified by: You can put your name here
Original Source: https://ligo.ertiqah.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();
})();

Important: Before pasting, modify the max_limit value in the script to specify how many invitations you want to withdraw. The default is set to 10.

If you get a "paste is blocked" message in Chrome, type "allow pasting" in the console and press Enter, then try pasting again.

4. Run the Script

After pasting the script, press Enter to run it. You'll see progress updates in the console as each invitation is withdrawn.

The script will:

1. Find all your pending invitations

2. Sort them by age (oldest first)

3. Withdraw the specified number of oldest invitations

4. Show you the progress in real-time

Tips for Optimal Results

• Start small: Test with 5-10 invitations first to see how it works

• Don't overdo it: LinkedIn may flag excessive automation, so don't withdraw hundreds at once

• Adjust the delay: If you're having issues, try increasing the delay_between_withdrawals value for more spacing between actions

• Cross-browser compatibility: This script should work in Chrome, Firefox, Edge, and other major browsers

• Monitor results: Check your sent invitations count before and after to confirm the withdrawal worked

FAQ: LinkedIn Invitation Management

Is there a way to see who hasn't accepted my invitations?

Yes! That's exactly what the sent invitations page shows you. Navigate to linkedin.com/mynetwork/invitation-manager/sent/ to see all your pending requests.

Will people know if I withdraw my invitation?

No, LinkedIn does not notify users when you withdraw a connection request. They'll simply stop seeing the invitation in their pending list.

How many connection requests can I have pending at once?

LinkedIn limits users to 500 pending invitations at any given time. Once you hit this limit, you need to withdraw old invitations before sending new ones.

Can I get penalized for using this script?

This script mimics natural human behavior by including delays between actions. However, use it responsibly-don't withdraw hundreds of invitations in rapid succession, as this could potentially trigger LinkedIn's automation detection.

Does withdrawing invitations free up my weekly invitation limit?

No, withdrawing invitations won't reset your weekly invitation limit (which is separate from the pending limit). It only frees up space in your pending invitations queue.

Streamline Your Entire LinkedIn Strategy

Managing pending invitations is just one piece of an effective LinkedIn presence. If you're a freelancer, consultant, or agency owner juggling multiple client accounts, you know how time-consuming content creation and engagement can be.

That's where LiGo comes in. Our AI-powered platform helps you:

• Generate engaging LinkedIn content based on your expertise

• Manage multiple client voices with distinct content themes

• Create intelligent comments that boost engagement

• Analyze your LinkedIn performance with detailed analytics

LiGo is specifically designed for busy professionals who understand the value of LinkedIn but don't have hours to spend crafting the perfect posts.

Related Resources

Want to learn more about optimizing your LinkedIn strategy? Check out these related articles:

• What Happens If I Withdraw a LinkedIn Invitation?

• Are There Any Limits on the Number of LinkedIn Invitations I Can Send?

• How to See Your Sent Invitations on LinkedIn

• Hacks to Bypass LinkedIn's Weekly Invitation Limit

Last updated: February 26, 2025