flin-linkedin-ads-mcp
Click on "Install 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., "@flin-linkedin-ads-mcplist my LinkedIn ad accounts"
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.
flin-linkedin-ads-mcp
flin-linkedin-ads-mcp ist ein strikt read-only MCP Server für LinkedIn Ads.
Er ist dafür gebaut, direkt in Claude über MCP eingebunden und getestet zu werden.
Features
Read-only Zugriff auf LinkedIn Ads Daten
Ad Accounts lesen
Campaign Groups lesen
Campaigns lesen
Creatives lesen
Share-Content lesen (
get_share_content, best effort für Bild-URLs)Insights/Analytics lesen
Company Intelligence lesen (
/accountIntelligence, private API Access nötig)Keine Schreiboperationen in
v0.1.x
Related MCP server: linkedin-campaign-manager-mcp
Scope v0.1.x (strict read-only)
Kein Create/Update/Delete
Kein Pause/Resume
Kein generischer Proxy-Endpunkt
Kein eingebauter OAuth-Refresh-Flow im MCP selbst
Direkt in Claude testen
Variante A: Lokal aus diesem Repo (empfohlen zum Entwickeln)
In Claude:
SettingsöffnenDeveloperöffnenMCP Config bearbeiten
Diesen Server eintragen:
{
"mcpServers": {
"flin-linkedin-ads-mcp-local": {
"command": "uv",
"args": [
"run",
"--directory",
"/Users/nicolasg/Antigravity/flin-linkedin-ads-mcp",
"flin-linkedin-ads-mcp"
],
"env": {
"LINKEDIN_ACCESS_TOKEN": "AQX...",
"LINKEDIN_API_VERSION": "202603",
"LINKEDIN_RESTLI_PROTOCOL_VERSION": "2.0.0"
}
}
}
}Danach Claude neu starten.
Variante B: Via uvx (wenn Paket publiziert ist)
{
"mcpServers": {
"flin-linkedin-ads-mcp": {
"command": "uvx",
"args": ["--refresh", "flin-linkedin-ads-mcp"],
"env": {
"LINKEDIN_ACCESS_TOKEN": "AQX...",
"LINKEDIN_API_VERSION": "202603",
"LINKEDIN_RESTLI_PROTOCOL_VERSION": "2.0.0"
}
}
}
}2-Minuten Smoke Test in Claude
Nach dem Restart in Claude diese Calls testen:
list_ad_accountslist_campaignsget_insightsmitpivot=campaign
Wenn list_campaigns eine Auswahl zurückgibt, den Call mit einem vorgeschlagenen ad_account_id wiederholen.
Hinweis zu get_insights:
Der MCP nutzt den LinkedIn
analyticsFinder mit Single-Pivot.Implementierung ist auf die Dokumentation
view=li-lms-2026-03ausgerichtet.date_fromist Pflicht (LinkedInadAnalyticserwartetdateRange).Unterstützte
fieldsfolgen der Metrics-Tabelle aus der offiziellen Reporting-Schema-Doku (max. 20 Felder pro Request).Der Server nutzt intern
pivot.value/timeGranularity.valueund hat zusätzlich einen Fallback auf Legacy-Parameternamen für bessere API-Kompatibilität.Neuere Video/Event-Felder sind enthalten, z. B.
videoWatchTime,averageVideoWatchTime,eventViews,eventWatchTime,averageEventWatchTime.
Beispiel für einen stabilen Test-Call:
{
"ad_account_id": "508834004",
"date_from": "2025-08-01",
"date_to": "2025-12-31",
"fields": [
"impressions",
"clicks",
"costInLocalCurrency",
"dateRange"
],
"pivot": "account",
"time_granularity": "MONTHLY"
}get_insights Parameter (2026-03)
Wichtigste Parameter:
pivot: z. B.account,campaign_group,campaign,creative,member_company_size,member_industry,member_seniority,member_job_title,member_job_function,member_country_v2,member_region_v2,member_company,member_county,share,company,conversiontime_granularity:DAILY,MONTHLY,ALL,YEARLYfields: Liste aus der offiziellen Metrics-Tabelle, maximal 20 Einträge, case-sensitiveKompatibilitätsfelder:
pivotValue→pivotValues,clickThroughRate(berechnet alsclicks / impressions),costPerClick(berechnet alscostInLocalCurrency / clicks)
date_from:YYYY-MM-DD(Pflicht)date_to: optional,YYYY-MM-DD
Facets/Filter:
ad_account_id(ein Konto) oderaccount_ids(mehrere Konten)optional zusätzlich:
campaign_ids,campaign_group_ids,creative_ids,share_ids,company_idsoptional:
campaign_type,objective_typeoptional Sortierung:
sort_by_field+sort_order(müssen zusammen angegeben werden)
Kompatibilität:
entity_idsbleibt für Backward-Kompatibilität erhalten (z. B. beipivot=campaign).
list_creatives / get_creative Bild-URL (optional)
Für Creative-Calls kann optional das Derived-Field imageUrl in fields angefordert werden.
imageUrlwird bevorzugt direkt aus dem Creative-contentextrahiert.Falls dort keine Bild-URL enthalten ist und eine
content.referenceaufurn:li:adDirectSponsoredContent:*zeigt, versucht der MCP zusätzlich eine Auflösung überadDirectSponsoredContents/{urn}.Falls dort keine Bild-URL enthalten ist und eine Share-Referenz vorhanden ist, versucht der MCP zusätzlich eine Auflösung über die referenzierte Share/Post-Entity.
Wenn keine Bild-URL auflösbar ist, ist
imageUrlnull.
Beispiel:
{
"ad_account_id": "508834004",
"id": "urn:li:sponsoredCreative:935973186",
"fields": ["id", "name", "imageUrl"]
}list_account_intelligence (202603)
Neues Tool:
list_account_intelligence
Dieser Endpunkt nutzt GET /rest/accountIntelligence?q=account und ist laut LinkedIn private API (zusätzliche Freischaltung erforderlich).
Wichtige Parameter:
ad_account_id(oder Auto-Resolve bei genau einem Account)lookback_window:LAST_7_DAYS,LAST_30_DAYS,LAST_60_DAYS,LAST_90_DAYSoptional:
ad_segment_ids,campaign_idoptional:
skip_company_decorationoptional:
page_start,page_size(max. 1000)
Wichtige Response-Felder:
companyName,engagementLevelpaidImpressions,paidClicks,paidEngagements,paidLeadspaidQualifiedLeads,conversions(ab API-Version202603)organicImpressions,organicEngagements
Beispiel:
{
"ad_account_id": "508834004",
"lookback_window": "LAST_30_DAYS",
"page_size": 100
}get_share_content (best effort)
Neues Tool:
get_share_content
Wichtige Parameter:
share_urn(Pflicht, Formaturn:li:share:<id>)include_raw(optional,truegibt zusätzlich das rohe API-Payload zurück)
Response enthält u. a.:
share_urn,source_endpoint(sharesoderposts)post_url(LinkedIn Feed URL)textimage_url(erstes gefundenes Bild odernull)image_urls,thumbnail_urls
Beispiel:
{
"share_urn": "urn:li:share:7379073146093568000",
"include_raw": false
}Troubleshooting get_insights
Bei ILLEGAL_ARGUMENT oder RESOURCE_NOT_FOUND bitte prüfen:
Feldnamen sind exakt korrekt (
clicksstattclick,impressionsstattimpression).Maximal 20
fields.Mindestens ein gültiger Facet-Filter (
ad_account_id/account_idsoder andere Facets).IDs im korrekten Format (Account/Campaign/Campaign Group/Creative numerisch oder URN;
share_idsundcompany_idsals URN).Datum im Format
YYYY-MM-DD.date_fromist gesetzt (ohnedateRangeantwortet LinkedIn oft mitILLEGAL_ARGUMENT).pivotist einer der dokumentierten Werte (siehe oben).
Schneller API-Gegencheck (ohne MCP) für das Token:
curl -i 'https://api.linkedin.com/rest/adAccounts?q=search&pageSize=1' \
-H 'Authorization: Bearer DEIN_ACCESS_TOKEN' \
-H 'Linkedin-Version: 202603' \
-H 'X-Restli-Protocol-Version: 2.0.0'LinkedIn Access Token generieren (Schritt für Schritt)
Voraussetzung:
LinkedIn Developer App vorhanden
Marketing API Zugriff für die App freigeschaltet
Scope
r_adsfür Entities (Accounts/Campaigns/Creatives)Scope
r_ads_reportingfürget_insightsDie Ad Accounts sind in der Developer App unter
Products -> View Ad AccountsgemapptDer authentifizierte User hat eine Ad-Account-Rolle (mind.
VIEWER)
1) App in LinkedIn Developer Portal vorbereiten
In der App unter
Auth:Client IDundClient SecretnotierenRedirect URL hinzufügen, z. B.
http://localhost:9876/callback
In der App sicherstellen, dass die Marketing/Ads Berechtigungen aktiviert sind (
r_ads+r_ads_reporting)
2) Authorization Code holen
Im Browser öffnen (Werte ersetzen, redirect_uri URL-encoden).
Für diesen MCP müssen im Scope mindestens enthalten sein:
r_ads(Accounts/Campaigns/Creatives)r_ads_reporting(get_insights)
Optional (nur wenn deine App dafür freigeschaltet ist):
offline_access(für Refresh-Token-Flow)
Empfohlene URL für den MCP (ohne Refresh-Token):
https://www.linkedin.com/oauth/v2/authorization?response_type=code&client_id=DEIN_CLIENT_ID&redirect_uri=http%3A%2F%2Flocalhost%3A9876%2Fcallback&scope=r_ads%20r_ads_reporting&state=dein_csrf_stateVariante mit optionalem offline_access:
https://www.linkedin.com/oauth/v2/authorization?response_type=code&client_id=DEIN_CLIENT_ID&redirect_uri=http%3A%2F%2Flocalhost%3A9876%2Fcallback&scope=r_ads%20r_ads_reporting%20offline_access&state=dein_csrf_stateNach Login/Consent leitet LinkedIn auf deine Redirect-URL zurück:
http://localhost:9876/callback?code=AUTH_CODE&state=dein_csrf_stateDen code aus der URL kopieren.
3) Authorization Code gegen Access Token tauschen
curl -X POST 'https://www.linkedin.com/oauth/v2/accessToken' \
-H 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'grant_type=authorization_code' \
--data-urlencode 'code=AUTH_CODE' \
--data-urlencode 'redirect_uri=http://localhost:9876/callback' \
--data-urlencode 'client_id=DEIN_CLIENT_ID' \
--data-urlencode 'client_secret=DEIN_CLIENT_SECRET'Beispiel-Response:
{
"access_token": "AQX...",
"expires_in": 5183999
}access_token als LINKEDIN_ACCESS_TOKEN in die Claude MCP Config übernehmen.
Wichtig: Bei diesem MCP erfolgt Authentifizierung über env in der MCP Config.
Es gibt hier keinen eingebauten OAuth-Refresh-Flow im Server selbst.
Wenn der Token abläuft, musst du einen neuen Token erzeugen und in der Config ersetzen.
4) Ablauf / Erneuerung
Access Tokens laufen typischerweise nach ca. 60 Tagen ab.
Dann OAuth-Flow erneut durchführen.
Falls deine App für programmatic refresh tokens freigeschaltet ist, kannst du stattdessen per Refresh Token erneuern.
5) 401/403 schnell diagnostizieren
Token gegen Ads-Account-Endpunkt testen:
curl -i 'https://api.linkedin.com/rest/adAccounts?q=search&pageSize=1' \
-H 'Authorization: Bearer DEIN_ACCESS_TOKEN' \
-H 'Linkedin-Version: 202603' \
-H 'X-Restli-Protocol-Version: 2.0.0'Interpretation:
401 Unauthorized: Token abgelaufen, widerrufen oder falscher Scope-Set wurde neu konsentiert403 Forbidden: Token ist gültig, aber Scope/Rolle/App-Mapping fehlt200 OK: Auth grundsätzlich korrekt
Environment Variablen
Pflicht:
LINKEDIN_ACCESS_TOKEN
Optional:
LINKEDIN_API_VERSION(Default:202603)LINKEDIN_RESTLI_PROTOCOL_VERSION(Default:2.0.0)LINKEDIN_TIMEOUT_SECONDS(Default:30)LINKEDIN_MAX_RETRIES(Default:3)
Lokale Entwicklung
cd /Users/nicolasg/Antigravity/flin-linkedin-ads-mcp
python -m pip install -e ".[dev]"
pytest -q
ruff check .
mypy srcSicherheit (wichtig)
Niemals
LINKEDIN_ACCESS_TOKENoder OAuth Secrets ins Repo committen.envist bereits in.gitignoreToken nur über MCP
envin Claude oder über lokale Shell-Umgebung setzenVor jedem Push prüfen:
git status
git diff -- .envWenn eine Datei mit Secrets auftaucht: Commit abbrechen und Secrets rotieren.
GitHub Actions & Release (PyPI-ready)
Dieses Repo enthält:
CI Workflow:
.github/workflows/ci.ymlRelease Workflow:
.github/workflows/release.yml
Der Release-Workflow macht bei v* Tags:
Lint + Typecheck + Tests
Build +
twine checkTrusted Publishing zu PyPI
GitHub Release mit
dist/*Artefakten
Node-20-Deprecation-Warnungen sind abgefangen durch:
aktuelle Actions-Majors (
checkout@v6,setup-python@v6)FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: truein beiden Workflows
PyPI Trusted Publisher einmalig einrichten
PyPI Project:
flin-linkedin-ads-mcpOwner:
flin-agencyRepository:
flin-linkedin-ads-mcpWorkflow:
release.ymlEnvironment:
pypi
Release auslösen
git add -A
git commit -m "release: v0.1.0"
git tag v0.1.0
git push origin main --tagsOffizielle Referenzen
LinkedIn OAuth Overview:
Authorization Code Flow (native clients):
Reporting (Ad Analytics):
Reporting Schema (Metrics + Query Parameters):
Company Intelligence API:
Programmatic Refresh Tokens:
Available Tools
11 toolsget_ad_accountB
Fetch one LinkedIn ad account by id
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | ||
| fields | No |
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 only says 'Fetch' without disclosing behavioral traits such as idempotency, auth requirements, error handling, or rate limits. The description is too minimal to inform an agent about side effects or constraints.
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 sentence that efficiently conveys the core action. It is front-loaded with the verb and resource. However, it could structure additional details about parameters or return value without becoming verbose.
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?
Given the simplicity of a fetch-by-ID tool and no output schema, the description is adequate but incomplete. It does not explain the return value or the effect of the optional fields parameter. It could be more complete with a brief note on what is returned.
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% (no descriptions in the schema). The description mentions 'by id' for the id parameter but completely omits the optional 'fields' parameter, leaving its purpose unclear. The description adds minimal meaning beyond the parameter names.
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 clearly states the verb 'Fetch', the resource 'one LinkedIn ad account', and the method 'by id'. It distinguishes from sibling tools like list_ad_accounts (which fetches multiple) and other get_* tools for different resources.
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 description implies usage for fetching a specific ad account by ID but provides no explicit when-to-use or when-not-to-use guidance compared to alternatives. There are no exclusion conditions or prerequisites mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_campaignC
Fetch one campaign by id
| Name | Required | Description | Default |
|---|---|---|---|
| ad_account_id | No | ||
| id | Yes | ||
| fields | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits. It only states the basic operation, omitting whether the call is read-only, idempotent, or what happens on invalid id. Minimal transparency.
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 concise sentence with no fluff. It is front-loaded and efficient, though it could benefit from slight elaboration without becoming verbose.
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?
Given 3 parameters, no output schema, and no annotations, the description is inadequate. It does not explain optional parameters, return value structure, or error handling, leaving significant gaps.
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 schema has 0% description coverage, and the description adds no meaning beyond the parameter names. It fails to explain ad_account_id, fields, or their roles in the query.
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 'Fetch one campaign by id' clearly states the action (fetch) and resource (campaign) with a specific identifier. It distinguishes from sibling tools like list_campaigns by implying a single item, but does not explicitly differentiate from get_campaign_group.
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?
No guidance is provided on when to use this tool versus alternatives, nor any prerequisites (e.g., the id must be obtained from list_campaigns). The description lacks context for appropriate selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_campaign_groupB
Fetch one campaign group by id
| Name | Required | Description | Default |
|---|---|---|---|
| ad_account_id | No | ||
| id | Yes | ||
| fields | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It discloses the basic behavior (fetching by id) and implies it is read-only. However, it lacks details on error handling, authentication requirements, or other behavioral traits, which would enhance transparency.
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 extremely short (5 words) yet contains all essential information for a single-fetch operation. Every word serves a purpose, and there is no redundancy.
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?
Given the low complexity of the tool (simple fetch, 1 required param, no output schema), the description provides minimal but sufficient context. However, it does not explain optional parameters or return behavior, which would make it more 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?
The schema has 3 parameters with 0% description coverage, and the description does not add any meaning beyond what the schema provides. It only mentions 'id', ignoring 'ad_account_id' and 'fields'. This fails to compensate for the lack of parameter descriptions.
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 clearly states the verb ('Fetch'), resource ('campaign group'), and key parameter ('by id'). It effectively conveys the core function. However, it does not explicitly distinguish this tool from its siblings like 'list_campaign_groups', so it misses the top score.
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 description implies usage when one has a campaign group id, but it does not provide explicit guidance on when to use this tool versus alternatives (e.g., 'list_campaign_groups' for multiple). No exclusions or prerequisites are mentioned, so it falls into 'implied usage'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_creativeC
Fetch one creative by id
| Name | Required | Description | Default |
|---|---|---|---|
| ad_account_id | No | ||
| id | Yes | ||
| fields | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description does not disclose behavioral details such as read-only nature, error handling for non-existent IDs, or rate limits. Minimal transparency.
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?
Description is very concise (5 words) but lacks additional context that would be helpful. Appropriate for a simple tool but could be improved.
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?
No output schema and no description of return value. Missing information about error handling or behavior when creative is not found.
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%; description does not explain optional parameters like ad_account_id or fields. Missing meaning beyond the schema.
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?
Description clearly states the action (fetch) and resource (creative by id), distinguishing it from list_creatives which fetches multiple.
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?
No guidance on when to use this tool versus alternatives like list_creatives. Lacks context about prerequisites or use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_insightsC
Fetch LinkedIn ads analytics
| Name | Required | Description | Default |
|---|---|---|---|
| ad_account_id | No | ||
| pivot | No | campaign | |
| entity_ids | No | ||
| account_ids | No | ||
| campaign_group_ids | No | ||
| campaign_ids | No | ||
| creative_ids | No | ||
| share_ids | No | ||
| company_ids | No | ||
| fields | No | ||
| time_granularity | No | DAILY | |
| date_from | Yes | ||
| date_to | No | ||
| campaign_type | No | ||
| objective_type | No | ||
| sort_by_field | No | ||
| sort_order | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits (e.g., read-only, authentication needs, rate limits). The agent is left without information on side effects or constraints, which is critical for a data-fetching tool with no behavioral hints.
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 extremely concise (two words), but this brevity sacrifices informativeness. While concise, it is not well-structured or front-loaded with key information, earning a mid-range score.
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?
Given the high complexity (17 parameters, 6 enums, no output schema) and lack of annotations, the description is severely incomplete. It provides almost no contextual details, leaving the agent inadequately prepared to use the tool correctly.
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 tool description adds no meaning to the 17 parameters. The schema provides patterns and enums but no explanations; the description fails to compensate, leaving the agent to guess parameter purposes.
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 'Fetch LinkedIn ads analytics' is a clear verb+resource but lacks specificity about the type of analytics or insights. It differentiates from sibling tools like get_ad_account and list_campaigns, but does not elaborate on the scope (e.g., performance metrics, demographics).
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?
No guidance is provided on when to use this tool instead of alternatives. For a tool with 17 parameters and many siblings, explicit usage context is missing, leaving the agent to infer from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_account_intelligenceC
List company-level account intelligence rows (private LinkedIn API access required)
| Name | Required | Description | Default |
|---|---|---|---|
| ad_account_id | No | ||
| lookback_window | No | LAST_90_DAYS | |
| ad_segment_ids | No | ||
| campaign_id | No | ||
| skip_company_decoration | No | ||
| page_start | No | ||
| page_size | No | ||
| fields | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions the API requirement and omits key traits such as whether the operation is read-only, any pagination behavior, rate limits, or consequences of use. This is a significant gap.
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 sentence, very concise but at the expense of substance. For a tool with 8 parameters, it should include structured guidance or parameter hints. The extreme brevity here is under-specification rather than effective conciseness.
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?
Given the complexity (8 parameters, no output schema, no annotations), the description is severely incomplete. It does not explain what account intelligence rows are, how parameters interact, or what the output format is. The information provided is insufficient for an agent to use the tool correctly.
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%, meaning no parameter has a description in the schema. The tool description does not elaborate on any of the 8 parameters (e.g., ad_account_id, lookback_window, fields), providing zero additional meaning beyond their names and basic types.
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 clearly states it lists company-level account intelligence rows, specifying the verb and resource. The addition of '(private LinkedIn API access required)' provides a basic distinguishing requirement, but it does not explicitly differentiate from sibling list tools like list_ad_accounts or list_campaigns, preventing a 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 description offers no guidance on when to use this tool versus alternatives, nor does it mention when not to use it. The only hint is the API access requirement, which is insufficient for guiding tool selection among the many sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_ad_accountsC
List LinkedIn ad accounts accessible by the token
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | ||
| search | No | ||
| page_size | No | ||
| page_token | No | ||
| sort_order | No | ||
| test | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description bears full burden. It does not disclose pagination behavior, sorting, rate limits, authentication details beyond implicit token, or any side effects. For a listing tool, this is insufficient.
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 sentence, very concise. However, it is so brief that it sacrifices substance for brevity, making it minimally helpful.
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?
Given no output schema, 6 undocumented parameters, and no annotations, the description is severely incomplete. It fails to explain response format, pagination, filtering, or any behavioral details needed for proper use.
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 adds no meaning to any of the 6 parameters. Parameters like fields, search, page_size, page_token, sort_order, and test remain unexplained, providing no additional value over the raw schema.
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 clearly states 'List LinkedIn ad accounts accessible by the token', specifying the verb, resource, and scope. It effectively differentiates from sibling tools like get_ad_account (singular) and list_campaigns (different resource).
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?
No guidance on when to use this tool versus alternatives. No mention of prerequisites, typical use cases, or when other tools like get_ad_account would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_campaign_groupsC
List campaign groups for an ad account
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | ||
| search | No | ||
| page_size | No | ||
| page_token | No | ||
| sort_order | No | ||
| test | No | ||
| ad_account_id | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, and the description does not disclose any behavioral traits such as pagination, sorting, filtering behavior, rate limits, or what exactly a 'campaign group' entails. The agent gets no insight into side effects or operational context.
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 very concise at 6 words, but it is too brief for the complexity of the tool. It is front-loaded but does not earn its place by providing enough context for correct invocation.
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?
Given the high number of parameters (7), lack of parameter descriptions, no output schema, and many sibling tools, the description is completely inadequate. It fails to explain what a campaign group is, how to use parameters, or what the response contains.
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?
With 0% schema description coverage, all 7 parameters are left entirely undocumented. The description adds no information about any parameter, failing to compensate for the missing schema descriptions. This is a critical 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 clearly states the action (List) and resource (campaign groups) and specifies scope (for an ad account). However, it does not differentiate from sibling tools like list_campaigns or list_creatives, which also list similar resources.
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?
No guidance is provided on when to use this tool vs alternatives. The agent is left to infer from the name, but with many sibling tools, explicit when-to-use or when-not-to-use instructions are missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_campaignsC
List campaigns for an ad account
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | ||
| search | No | ||
| page_size | No | ||
| page_token | No | ||
| sort_order | No | ||
| test | No | ||
| ad_account_id | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It fails to disclose important behavior such as pagination (page_size, page_token), search, sorting, or result limits. The description is too minimal to inform the agent of side effects or constraints.
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?
While the description is very short (one sentence), it sacrifices necessary information. It is under-specified rather than concisely complete. Important details about parameters and behavior are missing.
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?
With 7 parameters, no output schema, and no annotations, the description is severely incomplete. It does not cover how to use pagination, filtering, sorting, or what the response will contain.
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 does not explain any of the 7 parameters. It does not add meaning beyond the schema. For example, 'fields', 'search', 'page_size' remain opaque.
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 clearly states the tool lists campaigns for an ad account, which is specific and distinct from sibling tools like get_campaign (individual) and list_campaign_groups (campaign groups). However, it could further differentiate from list_creatives or list_ad_accounts.
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?
No guidance on when to use this tool vs alternatives like get_campaign or list_campaign_groups. The description provides no context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_creativesC
List creatives for an ad account
| Name | Required | Description | Default |
|---|---|---|---|
| ad_account_id | No | ||
| campaign_id | No | ||
| creative_ids | No | ||
| fields | No | ||
| page_size | No | ||
| page_token | No | ||
| sort_order | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must disclose behavioral traits. It only says 'list' which implies a read operation, but fails to mention pagination, authentication needs, or default behavior with no parameters.
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 sentence and thus concise, but it is overly minimal and lacks structure such as a separation of purpose, usage, or parameter details.
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?
With 7 parameters, no output schema, and no annotations, the tool is complex yet the description is extremely sparse, omitting critical information like pagination behavior, return format, and parameter interdependencies.
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 description provides zero explanation for any of the 7 parameters, and the input schema has 0% description coverage, leaving the agent without guidance on how to construct valid requests.
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 clearly states the tool lists creatives for an ad account, but it does not differentiate from siblings like get_creative or list_campaigns, lacking specificity on scope.
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?
No guidance is provided on when to use this tool versus alternatives such as get_creative for a single creative, nor are typical use cases or prerequisites mentioned.
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. Dates show when Glama detected each change.
11 tool updates
v0.1.1- First observed
get_ad_account - First observed
get_campaign - First observed
get_campaign_group - First observed
get_creative - First observed
get_insights - First observed
get_share_content - First observed
list_account_intelligence - First observed
list_ad_accounts - First observed
list_campaign_groups - First observed
list_campaigns - First observed
list_creatives
TDQS
Each tool targets a distinct resource or operation (e.g., ad account, campaign, creative, insights), with clear prefixes like get_ for single items and list_ for collections, leaving no ambiguity.
All tool names follow a consistent verb_noun pattern using get_ or list_ prefixes, making the set predictable and easy to navigate.
With 11 tools, the set covers the core resources of a LinkedIn Ads API (accounts, campaigns, groups, creatives, insights) without being bloated or sparse.
The set is entirely read-oriented (get/list operations) and lacks any create, update, or delete tools, which are essential for full campaign lifecycle management in a LinkedIn Ads context.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for querying and analyzing data from ad platforms, analytics tools, and spreadsheets
Managed LinkedIn MCP server for AI agents: search, connect, message and enrich on accounts you own.
Hosted MCP server for Google Ads and LinkedIn Ads analysis.
- LinkMCPOAuthio.linkmcp
Hosted MCP server for LinkedIn: 31 tools for profiles, search, messaging, posts, enrichment.
Related MCP Servers
- AlicenseBqualityDmaintenanceAn MCP server that connects Claude to the LinkedIn Ads API for natural-language control over campaign management, audience targeting, creative uploads, analytics, and account auditing.3715MIT
- AlicenseAqualityBmaintenanceMCP server for the LinkedIn Marketing API — query campaigns, performance, and Lead Gen Forms from Claude in plain English. 19 read-only tools covering ad accounts, campaigns, creatives, performance analytics, demographics, video analytics, budget pacing, period comparisons, conversions, Lead Gen Forms, audiences, and targeting facets. Built for B2B paid social teams.194-
- AlicenseAqualityFmaintenanceA read-write MCP server for managing Google Ads campaigns, ad groups, keywords, and ads via natural language.122-
- AlicenseNot gradedqualityCmaintenanceAn MCP server that connects AI assistants to LinkedIn's Ad Library API for searching advertisers' sponsored content, job postings, and influencer partnerships.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/flin-agency/flin-linkedin-ads-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server