LinkedIn API Guide

LinkedIn API Message Send Rate Limits (Per Hour)

January 30, 2025

LinkedIn’s API enables developers to integrate powerful messaging capabilities into their applications, from automating outreach campaigns to building advanced chatbots and CRM features. However, like any robust platform, LinkedIn enforces message send rate limits to maintain user trust, prevent spam, and ensure a positive experience.

Understanding these limits is essential for developers to optimize messaging workflows, avoid 429 errors, and scale outreach effectively without violating LinkedIn’s guidelines. This guide will provide a detailed overview of LinkedIn API message send rate limits and practical strategies to stay compliant while maximizing the impact of your messaging features.

What Are LinkedIn API Message Send Rate Limits?

LinkedIn API imposes hourly message send limits to ensure fair usage and prevent abuse. These limits are applied on a per-user or per-organization basis and may vary depending on the specific use case or LinkedIn’s policies.

  • Typical Limit: The hourly rate limit may allow users to send 20–50 messages/hour per account, though exact thresholds are subject to LinkedIn’s discretion and the application type.
  • Endpoint: POST /messages is the primary endpoint for sending messages via LinkedIn API.

Why Does LinkedIn Enforce Rate Limits?
Rate limits exist to:

  1. Prevent Spam: Ensure that users do not receive excessive automated messages.
  2. Protect Resources: Safeguard LinkedIn’s infrastructure from being overloaded.
  3. Enhance User Trust: Maintain a professional and respectful messaging experience.

Implications for Developers
Exceeding these limits can result in 429 “Too Many Requests” errors, temporary throttling, or even permanent restrictions on API usage.

How to Identify Rate Limit Problems

When your application exceeds the messaging limit, LinkedIn responds with a 429 error. This error signals that further requests are temporarily blocked.

Key Headers to Monitor:

  • X-RateLimit-Limit: Maximum number of requests allowed within the current period.
  • X-RateLimit-Remaining: Number of requests remaining before hitting the limit.
  • X-RateLimit-Reset: Time (in seconds) until the rate limit resets.

Example 429 Response:

HTTP/1.1 429 Too Many Requests

X-RateLimit-Limit: 20

X-RateLimit-Remaining: 0

X-RateLimit-Reset: 3600

In this example, the user has reached the hourly limit of 20 messages, and the limit will reset in 3600 seconds (1 hour).

How to Diagnose Issues Effectively:

  1. Monitor API response headers to track usage in real-time.
  2. Log 429 errors and identify patterns in your messaging workflows (e.g., sudden bursts of requests).
  3. Use tools like Postman or LinkedIn’s API Sandbox to test message-sending behavior under controlled conditions.

Best Practices for Message Scheduling

  1. Distribute Messages Evenly:
    • Spread messages throughout the hour instead of sending them all at once.
    • Example: If the limit is 20/hour, send one message every 3 minutes to avoid bursts.
  2. Prioritize High-Value Targets:
    • Identify and focus on the most important recipients to maximize the impact of your messages within the available limit.

Use Batching and Queuing Systems

  • Batch Requests: Group messages into smaller batches to process them sequentially.
  • Queue Management: Implement a queue to schedule messages for future delivery, ensuring compliance with rate limits.

Implement Backoff Strategies
When encountering 429 errors, use exponential backoff to retry requests with increasing delays.

Example Python Code for Backoff:

import time

import requests

BASE_URL = "https://api.linkedin.com/v2/messages"

ACCESS_TOKEN = "YOUR_ACCESS_TOKEN"

def send_message(payload, retries=5):

    for attempt in range(retries):

        response = requests.post(

            BASE_URL,

            headers={"Authorization": f"Bearer {ACCESS_TOKEN}", "Content-Type": "application/json"},

            json=payload

        )

        if response.status_code == 429:

            retry_after = int(response.headers.get("X-RateLimit-Reset", 60))

            print(f"Rate limit hit. Retrying in {retry_after} seconds...")

            time.sleep(retry_after * (2 ** attempt))  # Exponential backoff

        else:

            return response.json()

    raise Exception("Max retries exceeded.")

message_payload = {

    "recipients": ["urn:li:person:12345"],

    "subject": "Hello!",

    "body": "This is a test message."

}

send_message(message_payload)

Monitor Usage Metrics Dynamically

  • Continuously track X-RateLimit-Remaining to adjust messaging frequency on-the-fly.
  • Use real-time dashboards to visualize API usage patterns and make data-driven decisions.

Adhering to LinkedIn’s Messaging Guidelines

  1. Personalize Messages:
    • Avoid generic, automated messages that could be flagged as spam.
    • Include recipient-specific details to improve engagement and compliance.
  2. Limit Automated Outreach:
    • Keep automated messages within reasonable limits to maintain user trust.
    • Combine automation with manual outreach for a balanced approach.
  3. Review LinkedIn’s Terms of Service:
    • Regularly update your workflows to align with LinkedIn’s guidelines.
    • Stay informed about changes in messaging policies to avoid penalties.

Scaling Responsibly:

  • If you need to scale, consider distributing the load across multiple user accounts or increasing the time interval between requests.
  • Use AI-driven tools to analyze recipient behavior and refine your messaging strategy over time.

Conclusion

Respecting LinkedIn API’s message send rate limits is essential for building compliant and efficient messaging workflows. By understanding these limits, diagnosing rate limit issues, and implementing best practices like scheduling, queuing, and backoff strategies, developers can scale messaging solutions effectively without violating LinkedIn’s policies.

Subscribe to our newsletter for expert tips on LinkedIn API integrations and advanced strategies for scaling your messaging workflows!