LinkedIn MCP
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@LinkedIn MCPDraft a LinkedIn post about our launch, don't publish yet"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
LinkedIn MCP
An approval-first Model Context Protocol (MCP) server for authorized LinkedIn workflows. It supports OAuth token exchange, basic OpenID profile retrieval, profile rewrite planning, post drafts, and explicit-approval publishing through LinkedIn's official Posts API.
API limitation: LinkedIn does not generally allow ordinary developer apps to edit a member's headline, About, experience, or skills directly. Those features are draft-and-review workflows unless LinkedIn grants a supported API capability. Access to products and scopes is controlled by LinkedIn.
Features
MCP tools usable by compatible LLM clients.
OAuth 2.0 authorization-code flow; secrets are read from environment variables.
Basic member profile fields through OpenID Connect
userinfo.Profile restructuring proposals without pretending to write unsupported fields.
Post drafting and explicit-approval publishing through the official API.
No browser scraping, password collection, or session-cookie automation.
Related MCP server: LinkedIn MCP Server
Quick start
Requirements: Python 3.11+, a LinkedIn developer app, and access to the products/scopes required for your intended operations.
git clone https://github.com/rohankumbhar-01/linkedin-mcp.git
cd linkedin-mcp
python -m venv .venv
source .venv/bin/activate
pip install -e .
cp .env.example .envSet LINKEDIN_CLIENT_ID, LINKEDIN_CLIENT_SECRET, and LINKEDIN_REDIRECT_URI in .env. Add the exact redirect URI in the LinkedIn Developer Portal. Do not commit .env or token files.
Run locally:
linkedin-mcpThe default transport is stdio, suitable for local MCP clients. The server also supports MCP_TRANSPORT=streamable-http, but do not expose it publicly until authentication, TLS, and network access controls have been configured. A public MCP endpoint needs its own client authentication and authorization layer; LinkedIn OAuth alone does not protect the MCP endpoint.
OAuth flow
Call
linkedin_start_oauth.Open the returned authorization URL and approve the permissions.
The redirect URL includes
codeandstate. Pass both tolinkedin_exchange_codein the same running server session.Call
linkedin_connection_statusandlinkedin_get_my_profile.
The configured redirect URI must exactly match the LinkedIn developer app setting. Requested scopes only work if the app has the relevant product access. The token is stored in ~/.linkedin-mcp/token.json with owner-only permissions where supported. For production, use a managed secret store or encrypted token storage and add refresh/revocation handling.
MCP tools
Tool | Purpose |
| Check token status without revealing it |
| Generate authorization URL and CSRF state |
| Exchange the code and store token |
| Read basic OpenID profile data |
| Prepare profile rewrite instructions; no writes |
| Prepare a post draft |
| Publish only when |
| Retrieve your posts when LinkedIn approves |
| Retrieve a specific post by URN where permitted |
| Delete a post only with explicit approval and API permission |
| Report implemented capabilities and API limitations |
LinkedIn API access
OAuth: https://learn.microsoft.com/en-us/linkedin/shared/authentication/authorization-code-flow
OpenID Connect: https://learn.microsoft.com/en-us/linkedin/consumer/integrations/self-serve/sign-in-with-linkedin-v2
Posts API: https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/posts-api
API terms: https://developer.linkedin.com/legal
Before production use, confirm the current supported LINKEDIN_API_VERSION, endpoint payload requirements, and app permissions against the official documentation. API access can vary by app/product approval.
Security checklist before remote hosting
Add authentication for MCP clients; never expose an unauthenticated public MCP endpoint.
Use HTTPS and a reverse proxy with strict access controls.
Store client secrets and tokens in a secret manager or encrypted store.
Implement token refresh/revocation and OAuth callback handling appropriate for the deployment.
Add audit logging without logging secrets or full tokens.
Keep publishing approval explicit and show the exact text before publishing.
Add tests and CI before using this with a real LinkedIn account.
Current scope and limitations
This is an initial implementation, not a promise that every LinkedIn action is available. It does not scrape LinkedIn pages or bypass access restrictions. Direct edits to headline, About, work experience, and skills are not implemented because those write operations are not generally available through standard member APIs. The initial OAuth exchange expects the authorization code and state to be submitted manually to the MCP tool; a production deployment should add a dedicated callback flow and state/session persistence.
License
MIT
Available Tools
11 toolslinkedin_capabilities_and_limitsA
Explain which features are implemented and which depend on LinkedIn API approval.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose the key behavioral fact that some features are gated by LinkedIn API approval. However, it does not say whether calling it requires an OAuth token or authenticated session, nor whether the answer varies per account, which matters for an agent deciding whether it can invoke it safely.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with no filler, and the substance (implemented vs approval-dependent) is front-loaded. Every phrase earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described, and with zero parameters the description is nearly complete. The only meaningful gap is the missing note on authentication requirements for invoking the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, so the baseline is 4. The description correctly frames the tool as parameterless and informational rather than suggesting any filtering or scope input.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Explain') and states the resource precisely: which features are implemented versus dependent on LinkedIn API approval. That is clearly distinct from the action-oriented siblings (auth, post, profile). It stops short of explicitly contrasting itself with any sibling, so a 4.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied – an agent can infer it should call this when unsure whether a capability is available. There is no explicit when-to-use, when-not-to-use, or naming of alternatives, and no prerequisites are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
linkedin_connection_statusA
Check whether a LinkedIn access token is stored; never returns the token.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It usefully discloses a security-relevant trait – the token is never returned – but says nothing about whether this is a purely local storage read or a live validation call against LinkedIn, nor about any auth prerequisites for the check itself. Output schema coverage limits how much return-value detail is needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with two clauses, both load-bearing: what it checks and what it will not expose. Front-loaded verb, zero filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-arg status check with an output schema, this is nearly sufficient – the storage-vs-validity semantics are clear. The remaining gap is whether an agent should treat a positive result as 'ready to post' or whether a separate validation step exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, so there is no parameter semantics to explain; the baseline of 4 applies. The description correctly avoids inventing parameter language for a no-arg tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Check whether a LinkedIn access token is stored.' The word 'stored' precisely scopes it to local credential presence rather than token validity, which is a meaningful distinction against siblings like linkedin_start_oauth and linkedin_exchange_code. It stops short of naming an alternative, but the operation is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied – an agent infers it should call this before attempting authenticated operations like linkedin_get_my_profile or linkedin_publish_approved_post, but the description never says so. No exclusions or alternative routing are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
linkedin_delete_approved_postB
Delete a post only after explicit approval. This is irreversible and depends on LinkedIn API access.
| Name | Required | Description | Default |
|---|---|---|---|
| approved | Yes | ||
| post_urn | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full load; it does disclose the two most important traits, irreversibility and an external LinkedIn API dependency. It omits what happens when approved is false, whether the delete is hard or soft, what scopes are needed, and what errors surface.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with the destructive warning and dependency up front and zero filler. Every clause carries information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The output schema means return values need not be described, and the destructive framing is present. What is missing is the parameter contract, especially the semantics of the approved flag, which matters for a destructive tool with no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain both parameters and does not. It gestures at approval but never ties it to the approved boolean or explains what false does, and post_urn is not explained at all (format, where to obtain it).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (delete a post) and pairs it with a gating condition, which separates it from linkedin_publish_approved_post in the sibling list. It never mentions the post_urn identifier, but the action is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'only after explicit approval' clause implies a precondition, but it does not say when to choose this over alternatives, nor does it name any sibling. The LinkedIn API access caveat hints at prerequisites without stating them.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
linkedin_draft_profile_changesB
Prepare suggested headline/About/experience text. This tool drafts only; it does not edit LinkedIn.
| Name | Required | Description | Default |
|---|---|---|---|
| skills | Yes | ||
| target_role | Yes | ||
| achievements | No | ||
| current_profile | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose the critical behavioral trait that this is a non-mutating draft-only operation with no effect on the live LinkedIn profile. It omits permission/auth requirements and what the returned draft looks like, but the most important side-effect question is answered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with no wasted words, and 'drafts only; does not edit' is front-loaded. Efficient, though arguably under-specified rather than truly concise about parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return-value explanation isn't needed, and the draft-only semantics are covered. However, with 4 undocumented parameters at 0% schema coverage and no usage workflow, the definition leaves real gaps for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description says nothing about the four parameters (current_profile, target_role, skills, achievements). An agent has no guidance on format, whether 'skills' is comma-separated, or what 'achievements' should contain, so the description fails to compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Prepare suggested') and names the concrete resources it drafts: headline, About, and experience text. It clearly signals a drafting operation distinct from editing, giving an agent enough to distinguish it from publish/edit siblings, though it doesn't name those siblings explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies usage (draft profile content) and states a key exclusion ('does not edit LinkedIn'), but it doesn't name the alternative that actually publishes or apply changes, nor does it explain the workflow relationship to siblings like linkedin_publish_approved_post. Usage is implied rather than prescribed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
linkedin_exchange_codeA
Exchange an OAuth authorization code for a token after checking the state generated in this session.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | ||
| state | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It does add real value by disclosing that state is validated against the session, but it omits what happens to the resulting token (stored? returned only?), the single-use nature of authorization codes, and failure modes on invalid state.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with the verb-action first and the prerequisite second. No filler and nothing to trim.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described, and both parameters get semantic coverage. The remaining gap is the missing link to linkedin_start_oauth and the token-handling behavior after exchange, which matters for a flow-terminal call.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate and it partly does: 'authorization code' and 'state generated in this session' map meaningfully to both required parameters. It still lacks format hints (where the code comes from, what the state string looks like) that an agent would need to supply correct values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: exchange an OAuth authorization code for a token. This clearly differentiates it from the sibling linkedin_start_oauth, which initiates the flow rather than completing it, though the description never names that sibling explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'after checking the state generated in this session' implies a prerequisite ordering in the OAuth flow, so usage is inferable. However, it never names linkedin_start_oauth as the source of the code/state, nor does it state what to do on state mismatch or whether the call can be retried.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
linkedin_get_my_postsB
Retrieve the authenticated member's posts. Requires LinkedIn approval for r_member_social.
| Name | Required | Description | Default |
|---|---|---|---|
| count | No | ||
| start | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose the OAuth scope/approval requirement — a real auth constraint. However it says nothing about pagination behavior, what happens when approval is missing, or caps on count, leaving meaningful behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, zero filler, with the purpose front-loaded before the prerequisite. Nothing could be removed without losing information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be explained, and the auth prerequisite is covered. But for a paginated list tool with two undocumented parameters and no error behavior, the description is only minimally adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description never mentions 'count' or 'start'. Two pagination parameters are left entirely undocumented in both structured and unstructured text, so the description fails to compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource with clear scope: 'Retrieve the authenticated member's posts.' An agent can distinguish this from linkedin_get_post (single post) by the 'my posts' framing, though no sibling is named explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'Requires LinkedIn approval for r_member_social' sentence gives a useful prerequisite, but there is no guidance on when to choose this over siblings like linkedin_get_post or linkedin_capabilities_and_limits, and no exclusions. Usage is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
linkedin_get_my_profileA
Read the signed-in member's basic OpenID profile fields, if the app has the required permissions.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so the description carries the full burden. It does disclose that this is a read of a limited 'basic OpenID' field set gated on app permissions, but adds nothing about failure behavior when permissions are missing, token requirements, or scope details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, front-loaded with the action and resource, and no filler. It is arguably a bit too terse for a tool with an auth prerequisite.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists so return values need not be described, but the auth/permission prerequisite and the relationship to the OAuth sibling tools go unstated, leaving a gap an agent could trip on.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, so the baseline applies; there is nothing parameter-wise for the description to compensate for.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource: read the signed-in member's basic OpenID profile fields. That clearly separates it from siblings like linkedin_get_my_posts or linkedin_connection_status, though it doesn't name the boundary explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied (fetch the current user's identity), and the permission caveat hints at a prerequisite, but it never says when to prefer this over sibling calls or that OAuth (linkedin_start_oauth / linkedin_exchange_code) must complete first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
linkedin_get_postC
Retrieve a specific post by its LinkedIn URN, if the app has permission.
| Name | Required | Description | Default |
|---|---|---|---|
| post_urn | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It mentions a permission condition but does not disclose that this is a read-only operation, what happens if permission is missing, or any rate limits or error behavior. The output schema covers return values, but behavioral context is sparse.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently conveys the core action and a key constraint. It is appropriately sized for a simple tool with one parameter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is low-complexity and has an output schema, so return values need not be explained. The description covers the permission prerequisite but omits usage differentiation from siblings and deeper behavioral details, making it minimally adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It does explain that the lone parameter is a 'LinkedIn URN,' adding meaning beyond the schema's bare 'string' type, but it does not specify URN format or examples. This partially compensates but leaves a gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Retrieve') and resource ('a specific post by its LinkedIn URN'), making the core action clear. It does not explicitly differentiate from the sibling tool linkedin_get_my_posts, which also retrieves posts, so a 4 rather than 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The only guidance is the conditional 'if the app has permission,' which is a prerequisite rather than a when-to-use directive. There is no mention of when to choose this over linkedin_get_my_posts or other alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
linkedin_prepare_postB
Validate and prepare a post for review; does not publish it.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| visibility | No | PUBLIC |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and its one valuable disclosure is that the call is non-publishing — a real safety-relevant fact. It says nothing about what validation rules apply, what happens when validation fails, what state the post is left in for review, or whether it is idempotent, all of which matter for a mutation-adjacent tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler; the non-publishing constraint is placed where it will be read. It is efficient but borders on under-specified given the zero schema coverage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be explained. However, for a tool with no annotations and 0% parameter coverage, the description should say more about validation outcomes and the review state; the missing parameter context is the main gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description never mentions either parameter. The 'text' parameter is obvious from its name, but 'visibility' is an unconstrained string defaulting to PUBLIC with no enum, and the description gives no guidance on accepted values or that PUBLIC is the default.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Validate and prepare a post for review') and explicitly negates publishing, which cleanly separates it from the sibling linkedin_publish_approved_post. It does not name that sibling directly, but the negation is enough for an agent to tell the two apart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Does not publish it' implies this is the first step in a draft-then-publish workflow, but the description never says when to call this versus linkedin_publish_approved_post, nor what prerequisites (auth, existing draft) must hold. Usage is inferable rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
linkedin_publish_approved_postB
Publish a post through LinkedIn's official Posts API only when the caller explicitly confirms approval.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| approved | Yes | ||
| visibility | No | PUBLIC |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden. It does add the useful behavioral gate (approval required) and identifies the underlying API, but omits that publishing is externally visible and effectively irreversible, whether it fails on duplicate content, and any rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler, and the approval condition lands before any caveat. It is lean to the point of under-specification for a mutation tool, but nothing in it is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an irreversible external mutation with no annotations and no schema descriptions, the description leaves out visibility defaults, text constraints, failure/return behavior, and the relationship to the draft tool. The output schema covers return values, but the calling contract is still thin.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so all three parameters are bare. The description explains the intent behind 'approved' but says nothing about 'text' (length/media constraints) or 'visibility' (its PUBLIC default and allowed values).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names a specific verb ('publish a post') and the exact channel ('LinkedIn's official Posts API'), so the agent knows this is the live-publishing action rather than the drafting one. It stops short of naming the sibling it pairs with (linkedin_prepare_post), so differentiation is implied rather than explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The precondition 'only when the caller explicitly confirms approval' gives an implied when-to-use rule, but the description never names linkedin_prepare_post as the drafting alternative nor says what to do when approval is not yet given. The caller must infer the two-step draft/publish workflow from the sibling list alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
linkedin_start_oauthA
Create a LinkedIn OAuth authorization URL. Open it and sign in to authorize the app.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the interaction step (open URL, sign in) but not prerequisites such as configured client credentials or redirect URI, nor what happens if the user is already authorized. The tool is simple and non-destructive, which limits the stakes, but the bar is higher without annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with zero waste. The purpose is front-loaded and the required user action follows immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be explained, and the tool is parameterless. The description covers the essential step but leaves the handoff to linkedin_exchange_code implicit, which would fully round out the OAuth flow for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing to disambiguate. Baseline 4 applies; the description needs no parameter detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Create a LinkedIn OAuth authorization URL.' This is clearly distinguishable from data-reading siblings like linkedin_get_my_profile. However, it doesn't explicitly name the follow-up tool linkedin_exchange_code, so the agent must infer the flow split between siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Open it and sign in to authorize the app' gives the user-facing action but no guidance on when to use this versus linkedin_connection_status (e.g., check first if already authorized) or when to proceed to linkedin_exchange_code. Usage is implied rather than specified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
11 tool updates
v0.1.0- First observed
linkedin_capabilities_and_limits - First observed
linkedin_connection_status - First observed
linkedin_delete_approved_post - First observed
linkedin_draft_profile_changes - First observed
linkedin_exchange_code - First observed
linkedin_get_my_posts - First observed
linkedin_get_my_profile - First observed
linkedin_get_post - First observed
linkedin_prepare_post - First observed
linkedin_publish_approved_post - First observed
linkedin_start_oauth
TDQS
Scored across 11 tools
Tools map cleanly to distinct steps: the three OAuth tools (status/start/exchange) are sequential and separable, and get_my_posts vs get_post vs delete_approved_post are clearly differentiated. Minor overlap between linkedin_connection_status and linkedin_capabilities_and_limits, and between the two 'draft' tools, but descriptions make the boundaries clear.
Every name uses the linkedin_ prefix with snake_case and mostly verb_noun structure (start_oauth, exchange_code, get_my_profile, prepare_post, publish_approved_post). A couple of names are noun phrases (connection_status, capabilities_and_limits), a small but readable deviation.
11 tools is well within the ideal range and each earns its place: three auth steps, profile read/draft, and a full post draft-publish-read-delete lifecycle. No filler or redundant tools.
Auth, profile read, and the post lifecycle are covered, but linkedin_draft_profile_changes is a dead end with no corresponding apply/publish tool, and there is no token refresh, revoke/logout, or engagement (comment/reaction) surface. Some gaps are attributable to documented LinkedIn API restrictions, but agents still hit walls.
Related MCP Connectors
LinkedIn campaigns, content, leads and inbox from your AI client. Scoped, revocable keys.
LinkedIn jobs, companies and people for AI agents, plus messages and invites via your own account.
LinkedIn for AI agents: inbox, invitations, Sales Navigator search, posts, jobs, quotas, webhooks.
OAuth 2.1 short-link tools for AI agents with scoped tokens, approvals, audit logs, and revocation.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to interact with LinkedIn for posting, commenting, liking, and managing connections via OAuth2 authentication.23 npmMIT
- FlicenseAqualityDmaintenanceEnables LLMs and agents to interact with LinkedIn's REST API for managing profiles, creating posts, viewing connections, and overseeing organizations.52-
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to interact with LinkedIn using the official API for profile access, company management, and job postings.Apache 2.0
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to audit professional profiles, check policy compliance, preview posts, and publish explicitly confirmed text posts through LinkedIn's official API.MIT