LinkedIn API Pricing 2026: Is It Free, and What Does It Cost?

TLDR: The LinkedIn API is free. LinkedIn charges nothing per call and has no paid tier; what you pay instead is access. Personal-profile posting is self-serve, but company pages need Community Management API approval, a Development tier capped at 500 calls per app and 100 per member a day, and a screencast review to leave it. An image post is two API calls plus an upload, tokens expire every 60 days, and the API version must be bumped yearly. The only “LinkedIn APIs” that cost money are scrapers, and LinkedIn sues those. Checked against LinkedIn’s documentation on September 24, 2026.

Does LinkedIn have an API, and what does it cost?

LinkedIn has a REST API at api.linkedin.com, documented on Microsoft Learn since LinkedIn became a Microsoft company. It covers sign-in, posting as a member or a company page, reading page engagement, advertising, events, lead forms, conversions, and the data portability endpoints the EU’s Digital Markets Act forced into existence. Our two earlier guides cover the posting side in detail: the LinkedIn Posting API guide for the full OAuth and publishing flow, and how to post to LinkedIn via API for the direct-versus-unified comparison.

On cost, the primary source is Section 8.2 of the API Terms of Use:

“The APIs are currently provided for free, but LinkedIn reserves the right to charge for the APIs in the future.”

The same section adds that if a fee is introduced you are not obliged to keep using the APIs. So the honest answer to “LinkedIn API pricing” is that there is no price list. There is no free tier and paid tier, no per-call metering, no key you buy. The only money that moves through a LinkedIn API is ad spend on the Advertising API, and that pays for ads, not calls. This is different from X, which charges per post and per read since February 2026 and whose rates we broke down in the X API pricing guide, and different from the paid data APIs that Google will happily show you when you search this phrase. Meta works like LinkedIn, free and gated, as the Instagram API pricing guide explains.

What LinkedIn does instead of charging is gate. Every capability is a product you add to your app, and the products that matter require an application, a business, a LinkedIn Page, and a review. That gating, plus the rate limits, upload steps, and token rules that come with it, is the real cost structure, and it is what the rest of this guide lays out.

Which LinkedIn API products are free and self-serve, and which need approval?

The developer portal’s Products tab is where access is decided. LinkedIn’s Getting Access page lists exactly three open permissions available to every developer without approval: profile and email from Sign In with LinkedIn, and w_member_social from Share on LinkedIn. Everything else needs an application. This is the 2026 list, from LinkedIn’s access and permissions documentation:

Two rows cover most developers. If you only need to post as a person, Sign In plus Share on LinkedIn gives you a working integration in an afternoon with no review at all. Note the word “member” in w_member_social: it posts to the profile of whoever signed in, never to a company page. The moment you need a company page, comments, or analytics, you are in the Community Management API, and that is where the process starts.

Two historical notes that still cause confusion. r_liteprofile and r_emailaddress were retired for new apps in 2023 and replaced by the OpenID Connect scopes and the /v2/userinfo endpoint, so any tutorial that requests them is out of date. And the “Marketing Developer Platform” that older articles describe was split: organization posting and engagement became the Community Management API in 2023, and ads stayed under the Advertising API. Both sit under what LinkedIn now calls the Marketing API Program, and both old and new names still appear in LinkedIn’s own docs.

What does LinkedIn API access actually cost: the access-and-cost matrix

Since the fee is zero everywhere, the useful comparison is what each route costs in time, limits, and prerequisites.

The two costs that surprise teams are the Development tier ceiling and the rejection rule. A hundred calls per member and five hundred per app a day is enough to build against and not enough to serve customers; the call-budget table further down shows how quickly a scheduler burns through it. And if a Standard tier application is rejected, LinkedIn’s review page says you cannot resubmit from the same app: you create a new developer app and start over at the Development tier, which resets your client ID and invalidates every token your users granted.

How do you get a LinkedIn API key?

There is no “API key” in the sense of a single string you buy. LinkedIn issues a client ID and client secret per app, and every call is authorised with a member access token obtained through OAuth 2.0. The steps:

1. Create an app at the developer portal. You must associate it with a LinkedIn Page you administer, even for personal-profile posting; a placeholder company page is fine.
2. Have a super admin of that Page verify the app. Until then the app is unverified and most products cannot be added.
3. Add products. Sign In with LinkedIn using OpenID Connect and Share on LinkedIn are granted immediately. Apply for the Community Management API if you need pages, comments, or analytics.
4. Set your redirect URLs, copy the client ID and secret, and run the authorization code flow to get a member token. The authorization code LinkedIn redirects back with expires after 30 minutes, so exchange it immediately.

The app name and logo cannot contain “LinkedIn”, “Linked”, or “In”, and the application form wants a business email address; LinkedIn’s review page says personal addresses will not pass vetting. One more rule we learned building PostZen’s company-page support: the Community Management API must be the only product on its app, so a production integration ends up with two LinkedIn apps, one for OpenID Connect sign-in and one for community management, each with its own client ID.

Community Management API: what the Development and Standard tiers cost you

Every Community Management API app starts in the Development tier. The documented limits:

Before any of that, check that you qualify. LinkedIn’s review page says the Community Management APIs are available only to registered legal organizations with commercial use cases, so an individual developer or a side project cannot get the Development tier at all. Getting it needs your organization’s legal name, registered address, website, and privacy policy, a verified business email, and the Page verification above.

Getting the Standard tier needs a finished product and a screencast. LinkedIn publishes a demo script per use case, and the recording has to show the real thing: the OAuth consent screen, a post being published and appearing on LinkedIn, comments loading with the commenter’s profile fields, and so on, for each of the categories you declared (page management, brand engagement, page analytics, executive management, employee advocacy). Reviewers get test credentials and a downloadable, high-resolution recording, and the docs recommend narration.

LinkedIn publishes no timeline for the review. The one product with a stated turnaround is the Pages Data Portability API at about seven business days; Community Management reviews are widely reported to take weeks, and the documentation states plainly that meeting the minimum requirements does not guarantee an upgrade. Budget for that. If company-page posting is on your roadmap, submit before you need it, not when a customer asks.

How long do LinkedIn API tokens last, and what does that cost?

Three lifetimes govern every LinkedIn integration:

• Authorization codes last 30 minutes. If the exchange fails or is slow, the member starts over.
• Access tokens last 60 days. After that, calls return 401 and the member has to go through OAuth again. LinkedIn does not issue long-lived access tokens.
• Programmatic refresh tokens last 365 days, and only for apps LinkedIn has enabled them for; the OAuth guide calls this “a limited set of partners”, and the refresh token page ties it to approved Marketing API partners. The refresh token’s clock starts at the original authorization and is never extended: on day 59 a refresh gives you a new 60-day access token and a refresh token with 306 days left; on day 360 both expire in five days and the member must reauthorize.

An app without refresh tokens, which includes every app that only has Share on LinkedIn, has one way to renew: send the member back through the authorization URL before day 60. LinkedIn skips the consent screen if the member is still logged in to linkedin.com and the old token has not expired, so the renewal can be a redirect instead of a prompt, but it still needs the member present in a browser.

So even in the best case, every LinkedIn user of your product reauthorizes once a year, and in the common case every 60 days. That reauthorization is a product cost: a scheduled post that lands after the token expired fails, and the user has to notice. PostZen’s LinkedIn connection stores both expiries, marks the account as needing reauthorization when a token stops working, and fires an account webhook so your app can prompt the user instead of discovering the failure in a stalled queue. LinkedIn’s docs also reserve the right to revoke either token at any time for technical or policy reasons, so the fallback to a fresh login has to exist regardless.

Two related gotchas. A refresh never grants new scopes: if your app gains a permission after a user connected, that user must reauthorize to grant it, which is why adding company-page support to an existing integration means asking every user to reconnect. And size your token column generously: LinkedIn says access tokens are about 500 characters and recommends planning for at least 1,000.

LinkedIn API rate limits and versioning: the maintenance cost

LinkedIn’s rate limiting page says something few platforms admit: standard rate limits are not published for most endpoints. Each endpoint’s limit is shown per app in the developer portal’s Analytics tab as two numbers, an application limit and a member limit, both per day, resetting at midnight UTC. The tab only lists endpoints you have called at least once that day, so to see a limit you make one test call first. Exceeding either returns HTTP 429. Developer admins get an email at 75% of the application quota, delayed by one to two hours, and there is no member-level alert.

Two sets of numbers are published. The Share on LinkedIn page lists 150 requests per member and 100,000 requests per application per day, measured in UTC. That page documents the older /v2/ugcPosts endpoint and does not say whether the same ceilings apply to the versioned endpoints, so treat your Analytics tab as the source of truth for anything else. The other published figures are the Community Management Development tier caps above. Note that the Share on LinkedIn number is requests, not posts, and the next section shows why the difference matters.

Versioning is the other recurring cost. Every call to the versioned /rest/ base path must carry a Linkedin-Version: YYYYMM header. There is no default: omit it and the request errors. LinkedIn releases a version every month and supports each for a minimum of one year, after which it is sunset and calls with that header error too. The current version is 202609 (September 2026). The migrations table shows the rhythm: 202508 was sunset on August 17, 2026, 202509 on September 15, 2026, and 202510 goes on October 15, 2026. In practice that means a yearly engineering task: read the migration notes, bump the header, and retest. PostZen’s LinkedIn publisher pins 202607, which is supported until July 15, 2027, and bumps it on that schedule; LinkedIn is one of the few platforms where “do nothing” breaks an integration on a known date.

What does one LinkedIn post cost in API calls?

This is the part a price list would never show you. LinkedIn does not accept media inside a post. Images, videos, and documents are separate assets that you register, upload, and then reference by URN, so a post with media is always several calls. Every versioned call carries two headers that older tutorials omit: Linkedin-Version and X-Restli-Protocol-Version: 2.0.0.

Here is the image flow end to end, for a member post. The author is urn:li:person:{id}, where the id is the sub value from /v2/userinfo after OpenID sign-in, or urn:li:organization:{id} for a company page. The image’s owner must be the same URN as the post’s author.

import { readFile } from 'node:fs/promises'

const API = 'https://api.linkedin.com/rest'
const headers = {
  Authorization: `Bearer ${process.env.LINKEDIN_ACCESS_TOKEN}`,
  'Linkedin-Version': '202609',
  'X-Restli-Protocol-Version': '2.0.0',
}

// Commentary uses LinkedIn's "little" text format. Reserved characters must be
// backslash-escaped or the post fails or renders wrongly.
function escapeLittleText(text) {
  return text.replace(/[\\|{}@[\]()<>#*_~]/g, (c) => `\\${c}`)
}

export async function postWithImage({ author, text, imagePath, altText }) {
  // 1. Register the upload. Call 1 against your quota.
  const init = await fetch(`${API}/images?action=initializeUpload`, {
    method: 'POST',
    headers: { ...headers, 'Content-Type': 'application/json' },
    body: JSON.stringify({ initializeUploadRequest: { owner: author } }),
  })
  if (!init.ok) throw new Error(`initializeUpload ${init.status}: ${await init.text()}`)
  const { value } = await init.json()

  // 2. PUT the bytes to the upload URL LinkedIn returned.
  const upload = await fetch(value.uploadUrl, {
    method: 'PUT',
    headers: { Authorization: headers.Authorization },
    body: await readFile(imagePath),
  })
  if (!upload.ok) throw new Error(`upload ${upload.status}`)

  // 3. Create the post that references the image URN. Call 2.
  const post = await fetch(`${API}/posts`, {
    method: 'POST',
    headers: { ...headers, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      author,
      commentary: escapeLittleText(text),
      visibility: 'PUBLIC',
      distribution: {
        feedDistribution: 'MAIN_FEED',
        targetEntities: [],
        thirdPartyDistributionChannels: [],
      },
      content: { media: { id: value.image, altText } },
      lifecycleState: 'PUBLISHED',
      isReshareDisabledByAuthor: false,
    }),
  })
  if (post.status !== 201) throw new Error(`posts ${post.status}: ${await post.text()}`)

  // The new post's URN comes back in a header, not the body.
  return post.headers.get('x-restli-id')
}

The same flow in Python with requests:

import os
import re

import requests

API = "https://api.linkedin.com/rest"
HEADERS = {
    "Authorization": f"Bearer {os.environ['LINKEDIN_ACCESS_TOKEN']}",
    "Linkedin-Version": "202609",
    "X-Restli-Protocol-Version": "2.0.0",
}


def escape_little_text(text: str) -> str:
    return re.sub(r"([\\|{}@\[\]()<>#*_~])", r"\\\1", text)


def post_with_image(author: str, text: str, image_path: str, alt_text: str) -> str:
    # 1. Register the upload (API call 1).
    init = requests.post(
        f"{API}/images?action=initializeUpload",
        headers=HEADERS,
        json={"initializeUploadRequest": {"owner": author}},
        timeout=30,
    )
    init.raise_for_status()
    value = init.json()["value"]

    # 2. PUT the bytes to the returned upload URL.
    with open(image_path, "rb") as image:
        upload = requests.put(
            value["uploadUrl"],
            headers={"Authorization": HEADERS["Authorization"]},
            data=image,
            timeout=120,
        )
    upload.raise_for_status()

    # 3. Create the post that references the image URN (API call 2).
    post = requests.post(
        f"{API}/posts",
        headers=HEADERS,
        json={
            "author": author,
            "commentary": escape_little_text(text),
            "visibility": "PUBLIC",
            "distribution": {
                "feedDistribution": "MAIN_FEED",
                "targetEntities": [],
                "thirdPartyDistributionChannels": [],
            },
            "content": {"media": {"id": value["image"], "altText": alt_text}},
            "lifecycleState": "PUBLISHED",
            "isReshareDisabledByAuthor": False,
        },
        timeout=30,
    )
    post.raise_for_status()
    return post.headers["x-restli-id"]

Video and documents follow the same register-upload-reference pattern with more steps. A video’s initializeUpload takes the file size and returns a list of upload URLs, one per 4 MB part. You PUT each part, save the ETag header from every response, call finalizeUpload with the upload token and the ETags in order, then poll GET /rest/videos/{urn} until the status is AVAILABLE before you create the post. Videos run from 3 seconds to 30 minutes and 75 KB to 500 MB, MP4 only, and the upload URLs expire, typically 30 days after initialization. Documents take PDF, PPT, PPTX, DOC, or DOCX up to 100 MB and 300 pages through /rest/documents. Images must be JPG, PNG, or GIF under 36,152,320 pixels, and GIFs can have up to 250 frames.

Counting only calls to api.linkedin.com, with byte uploads listed separately, this is what each post type costs:

Now run those numbers against the Development tier. At 100 calls per member per day, one member can publish four 20-image posts and then nothing else, not even a status check. At 500 calls per app per day, your whole customer base shares roughly 250 single-image posts, before a single analytics read or comment fetch. On Share on LinkedIn’s 150 requests per member, if those ceilings apply to the versioned endpoints, a member gets seven 20-image posts a day. None of this costs money. All of it shapes what your product can promise.

What else does a direct LinkedIn integration have to handle?

The upload flow is the visible work. These are the costs that show up after launch:

• Author URNs and page roles. Posting as a page needs the member to hold the administrator, content administrator, or direct sponsored content poster role on it. You look that up through /rest/organizationAcls at connect time and store which pages each member can post to.
• Little text escaping, mentions, and hashtags. The commentary field uses LinkedIn’s “little” format. Parentheses, brackets, braces, @, #, *, _, ~, angle brackets, the pipe, and the backslash are reserved and must be escaped. A mention is @[Name](urn:li:organization:123) and only links if the name matches exactly, case included. A hashtag you want linked goes through the template {hashtag|\#|mytag}, because an escaped # renders as plain text.
• Link previews are your job. The Posts API does not scrape URLs, by design. For a link card you fetch the page’s title and image yourself, upload the image through the Images API, and pass its URN as the article thumbnail.
• No scheduling. PUBLISHED is the only lifecycle state the Posts API accepts at creation. A queue, a clock, and a worker that survives restarts are yours to build, which the social media scheduling API guide covers in depth.
• Data you are not allowed to keep. LinkedIn’s restricted-use page limits stored member social activity data to 48 hours and most member profile data to 24 hours, bans “social feed” use cases such as showing company updates on a website, and forbids using member data for sales, recruiting, or advertising targeting. An inbox or analytics feature has to re-fetch rather than cache.
• One quota for every customer. All of your users publish through your single app, so one customer’s bulk import can push the app into 429s for everyone. You need a queue that throttles per member and per app against limits LinkedIn only shows you in a portal, with an alert that arrives an hour or two late.
• Legacy endpoints in current docs. The Share on LinkedIn page still documents /v2/ugcPosts and the /v2/assets register-upload flow. The Posts API replaces ugcPosts and the Images API replaces the Assets API, so new code copied from that page starts life on the deprecated path. PostZen’s publisher runs entirely on the versioned endpoints.

None of these is hard alone. Together they are a small, stateful system that has to keep working for a feature that is usually one checkbox in the rest of your product.

What LinkedIn products get confused with API pricing?

Searching for LinkedIn API cost turns up prices for things that are not the API. None of these unlock any API access, scope, or rate limit:

• Sales Navigator is a per-seat subscription for salespeople. Its API, the Sales Navigator Application Platform, is a separate partner program, free as an API but available only to approved partners whose customers hold Sales Navigator licenses.
• Recruiter and Recruiter Lite are per-seat recruiting products. The Talent Solutions APIs (Recruiter System Connect, Apply Connect, Apply with LinkedIn) are partner programs for applicant tracking systems, again with no API fee but a partner application.
• Premium Career and Premium Business are consumer subscriptions with no developer component at all.
• LinkedIn Learning has an API, but access requires being a Learning partner or an organization with a Learning site license.
• The LinkedIn Marketing Partner Program is a badge for agencies and ad-tech vendors with a track record; it is not an API tier.

If a page quotes a monthly price for “the LinkedIn API”, it is either selling one of these products, an unofficial scraper, or a wrapper.

Unofficial LinkedIn APIs and scrapers: what they cost and why they end

The paid “LinkedIn APIs” on marketplaces like RapidAPI are scrapers: services that log in with pools of accounts or crawl public pages and resell the data, typically for tens to hundreds of dollars a month depending on volume. They are read-only, they cannot publish anything, and they violate LinkedIn’s User Agreement regardless of whether the data is public. LinkedIn litigates:

• hiQ Labs v. LinkedIn ran from 2017 to a settlement in December 2022. hiQ accepted a permanent injunction against scraping and agreed to destroy the data, with a judgment for LinkedIn on breach of contract and related claims. The case is remembered for an early appellate ruling favourable to scraping public data; it ended as a loss for the scraper.
• LinkedIn v. Nubela (Proxycurl) was filed in January 2025, alleging fake-account scraping resold through an API. Proxycurl settled and shut its API down in July 2025 after reaching a reported eight-figure annual run rate.

For a product, that history is the cost: any feature built on a scraper has an end date you do not control. The official API’s gating is slower and narrower, but the access it grants does not evaporate in a settlement. And if your goal is to publish, scrapers are not an option at all: the only ways to write to LinkedIn are the official API and services built on it.

What the free LinkedIn API cannot do

Free and approved still leaves gaps, and knowing them up front saves an application:

• No reading a member’s own feed or posts beyond what your app published. r_member_social is closed; LinkedIn’s docs say access requests are not being accepted.
• No comments or reactions on personal posts. r_member_social_feed is restricted to partners, so engagement reads work on company-page posts only.
• No messaging. There is no InMail or DM API for third parties.
• No long-form articles, newsletters, or events through the Posts API. Link posts with an article card are supported, but LinkedIn’s own article and newsletter editor has no API, and events live in the separate Events Management API.
• No organic carousels. The carousel content type is sponsored-only. The organic equivalents are document posts, which render as swipeable slides, and multi-image posts of 2 to 20 images.
• No native scheduling. Posts are created as PUBLISHED or not at all.
• Limited edits. A partial update can change a published post’s commentary and a few call-to-action fields, but not its media, and poll content cannot be edited at all. To change an image, delete and recreate.

Polls, which often appear on lists like this one, are supported: the Posts API creates organic polls with a question, two to four options, and a duration of one day, three days, one week, or two weeks. PostZen’s LinkedIn platform docs list what its LinkedIn target supports and what it rejects before publishing.

Should you apply to LinkedIn directly or use a unified API?

Building directly is the right call more often than a vendor will admit. It is free, and nothing sits between you and LinkedIn.

Apply directly when:

• You only post to the profile of whoever signs in. Share on LinkedIn is self-serve, needs no review, and the code above is most of the integration.
• LinkedIn is your core product, and owning uploads, escaping, token renewal, and the version cadence is part of the job.
• You need the Advertising API, or compliance rules forbid a third party from holding your users’ tokens.
• Your launch date can wait for a Standard tier review with no published timeline.

Use a unified API when:

• LinkedIn is one of several networks, and you do not want to build upload-then-post, token renewal, and rate-limit queues once per platform.
• You need scheduling, which the Posts API does not offer.
• You are shipping an AI agent and the tool needs to be one HTTP call with a stable schema.
• You would rather pay a subscription than own a yearly version bump and a portal-only quota.

One caution applies to every provider, PostZen included. Posting to company pages through any third party still depends on that provider’s own Community Management approval, so ask which tier its LinkedIn app holds before you promise company pages to your customers.

Posting to LinkedIn through PostZen instead of applying yourself

If the reason you are pricing the LinkedIn API is to publish, the unified route sidesteps the application for member profiles. PostZen holds the LinkedIn app, the version header, the upload flows, the little-text escaping, and the token expiry handling. You connect a member through a hosted OAuth link and send one request, with an optional scheduledFor time:

curl -X POST https://api.postzen.dev/v1/posts \
  -H "Authorization: Bearer $POSTZEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "We are hiring two backend engineers. Details at example.com/careers",
    "scheduledFor": "2026-10-01T14:00:00Z",
    "mediaItems": [
      { "url": "https://cdn.example.com/hiring.png" }
    ],
    "platforms": [
      {
        "platform": "linkedin",
        "accountId": "jh72r5nqk9wx3v8m1t4cz6bs0fy5dg3e"
      }
    ]
  }'

That request does everything the Node and Python examples above do, plus the queue they leave out. Text runs up to 3,000 characters, with up to 20 images, one video up to 500 MB, or one document up to 100 MB. Company-page publishing through settings.organizationUrn is built on the same versioned endpoints and is waiting on LinkedIn’s Community Management approval, the same review this guide describes, so PostZen publishes to member profiles today. The same request accepts nine other platforms, which the social media API page and our comparison of social media APIs cover. The LinkedIn integration page lists what the LinkedIn target supports, and PostZen’s plans are on the pricing page.

The LinkedIn API is free. Access to it is not effortless, a post is several calls, and the maintenance is not zero. Decide based on whether you want to own that relationship or rent it.