LinkedIn MCP server for AI agents
Let Claude, ChatGPT or your own agent read and act on LinkedIn: 66 typed functions through one MCP server. No LinkedIn API key needed.
- Site
- linkedin.com
- Functions
- 66
- Sign-in
- For account actions
- Works with
- MCP, HTTP, Node, Python
Connect
An MCP server for LinkedIn alone, with one tool per function. Paste it into Claude, ChatGPT, Cursor or any MCP client as a remote server.
https://api.bowmark.ai/mcp/site/linkedinOne MCP server for LinkedIn and every other site Bowmark covers. Your agent looks up what it needs and calls it.
https://api.bowmark.ai/mcpSet it up in your clientBoth need a Bowmark API key. The quickstart gets you one and a first result in a few minutes. Functions that need a login use the person's own account: how sign-in works.
Functions
Open a function to see its arguments, what it returns and how to call it.
getArticleReturns one long-form LinkedIn article or newsletter issue from its /pulse/ URL.Arguments
Name Type Required urlOrSlugstringYes Returns
LinkedinArticleinterface LinkedinArticle { slug: string; // the durable key for this article, pass it straight back to getArticle url: string; title: string; authorName: string | null; authorUrl: string | null; text: string; // the full body, every paragraph joined, never truncated imageUrl: string | null; publishedDate: string | null; // a real ISO timestamp modifiedDate: string | null; // null when LinkedIn reports the same instant as publishedDate likeCount: number | null; commentCount: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getArticleCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getArticle("memories-from-inspiring-trip-rwanda-bill-gates-ojyye");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getArticle("memories-from-inspiring-trip-rwanda-bill-gates-ojyye"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getArticle \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"urlOrSlug":"memories-from-inspiring-trip-rwanda-bill-gates-ojyye"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getArticle("memories-from-inspiring-trip-rwanda-bill-gates-ojyye");getCompanyReturns a company's public LinkedIn page from its company URL or handle.Arguments
Name Type Required urlOrHandlestringYes Returns
LinkedinCompanyinterface LinkedinCompany { id: string; // the URL handle, e.g. "microsoft", what getCompany takes companyId: string | null; // LinkedIn's numeric id, e.g. "1035", what listCompanyEmployees and searchMembers({ currentCompany }) take url: string; name: string; tagline: string | null; // the one-line pitch under the name description: string | null; // the company's own "About us" prose, newlines preserved website: string | null; industry: string | null; // ONE value, LinkedIn lets a company pick exactly one companySize: string | null; // the site's own BAND, e.g. "10,001+ employees" employeesOnLinkedin: number | null; // MEMBERS claiming this employer, not a headcount headquarters: string | null; // as displayed, e.g. "Redmond, Washington" address: LinkedinCompanyAddress | null; // the ld+json block, where one was published organizationType: string | null; // "Public Company", "Privately Held", "Nonprofit" foundedYear: number | null; specialties: string[]; // LinkedIn publishes ONE comma-joined string; this is it split logoUrl: string | null; } interface LinkedinCompanyAddress { streetAddress: string | null; addressLocality: string | null; addressRegion: string | null; postalCode: string | null; addressCountry: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getCompanyCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getCompany("<urlOrHandle>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getCompany("<urlOrHandle>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getCompany \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"urlOrHandle":"<urlOrHandle>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getCompany("<urlOrHandle>");getConversationReads one LinkedIn message thread in order, oldest first.Arguments
Name Type Required conversationstringYes Returns
{ conversationUrn: string; messages: LinkedinMessage[] }interface LinkedinMember { id: string | null; // profile id publicIdentifier: string | null; // URL slug, feeds getProfile / getProfileDetails url: string | null; name: string; firstName: string | null; lastName: string | null; headline: string | null; photoUrl: string | null; } interface LinkedinMessage { id: string | null; sender: LinkedinMember | null; text: string | null; sentAt: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getConversationCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getConversation("2-bm9uZXhpc3RlbnRfY2FuYXJ5XzEwMA==");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getConversation("2-bm9uZXhpc3RlbnRfY2FuYXJ5XzEwMA=="))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getConversation \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"conversation":"2-bm9uZXhpc3RlbnRfY2FuYXJ5XzEwMA=="}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getConversation("2-bm9uZXhpc3RlbnRfY2FuYXJ5XzEwMA==");getEventReturns one LinkedIn event by its URL or numeric id (from searchEvents).Arguments
Name Type Required inputstring | { event: string }Yes Returns
LinkedinEventDetailinterface LinkedinEventDetail { id: string; url: string; name: string; organizer: string | null; description: string | null; startsAt: string | null; // ISO endsAt: string | null; // ISO timezone: string | null; format: "online" | "in_person" | null; venue: string | null; attendees: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getEventCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getEvent("7250000000000000000");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getEvent("7250000000000000000"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getEvent \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"7250000000000000000"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getEvent("7250000000000000000");getGroupReturns one LinkedIn group by its URL or numeric id (from searchGroups or listMyGroups).Arguments
Name Type Required inputstring | { group: string }Yes Returns
LinkedinGroupDetailinterface LinkedinGroupDetail { id: string | null; url: string | null; name: string; description: string | null; members: string | null; // LinkedIn's member line, verbatim, "12K members", where the entity carries one }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getGroupCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getGroup("111111");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getGroup("111111"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getGroup \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"111111"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getGroup("111111");getHomeFeedReads the caller's LinkedIn home feed, newest first, with author, text, counts and URL for each post.Arguments
Name Type Required input{ count?: number; start?: number }No Returns
{ posts: LinkedinFeedPost[]; start: number; nextStart: number | null }interface LinkedinFeedPost { activityUrn: string | null; url: string | null; author: { name: string | null; headline: string | null; url: string | null }; text: string | null; postedAgo: string | null; // e.g. "2d" reactions: number | null; comments: number | null; reposts: number | null; promoted: boolean; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getHomeFeedCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getHomeFeed({ count: 3 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getHomeFeed({"count": 3}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getHomeFeed \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{"count":3}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getHomeFeed({ count: 3 });getJobReturns one job posting in full from its posting URL.Arguments
Name Type Required urlstringYes Returns
LinkedinJobPostinginterface LinkedinJobPosting { id: string; url: string; title: string; company: string | null; companyUrl: string | null; location: string | null; description: string; descriptionHtml: string; seniority: string | null; employmentType: string | null; jobFunction: string | null; industries: string | null; postedRelative: string | null; // the site's own phrase, e.g. "2 days ago" applicants: string | null; // bucketed, e.g. "Over 200 applicants" salaryRange: string | null; // only where the employer published one closed: boolean; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getJobCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getJob("<url>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getJob("<url>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getJob \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"url":"<url>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getJob("<url>");getLearningCourseReturns one LinkedIn Learning course in full.Arguments
Name Type Required urlOrSlugstringYes Returns
LinkedinLearningCourseDetailinterface LinkedinLearningCourseOutlineItem { title: string; duration: string | null; // e.g. "4m 10s" description: string; } interface LinkedinLearningCourseDetail { title: string; url: string; authorName: string | null; authorUrl: string | null; level: string | null; // "Beginner" / "Intermediate" / "Advanced" duration: string | null; // the whole course, e.g. "4h 23m" released: string | null; description: string; thumbnailUrl: string | null; viewerCount: number | null; outline: LinkedinLearningCourseOutlineItem[]; // the full chapter/lesson breakdown }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getLearningCourseCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getLearningCourse("python-essential-training-18764650");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getLearningCourse("python-essential-training-18764650"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getLearningCourse \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"urlOrSlug":"python-essential-training-18764650"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getLearningCourse("python-essential-training-18764650");getMyProfileReturns the signed-in caller's own LinkedIn member record.Arguments
None.
Returns
LinkedinMeinterface LinkedinMember { id: string | null; // profile id publicIdentifier: string | null; // URL slug, feeds getProfile / getProfileDetails url: string | null; name: string; firstName: string | null; lastName: string | null; headline: string | null; photoUrl: string | null; } interface LinkedinMe extends LinkedinMember { premium: boolean; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getMyProfileCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getMyProfile();import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getMyProfile())curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getMyProfile \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getMyProfile();getPostReads one public LinkedIn post.Arguments
Name Type Required urlOrIdstringYes Returns
LinkedinPostinterface LinkedinPost { id: string; // the numeric activity id, pass it straight back to getPost url: string; authorName: string | null; authorUrl: string | null; text: string; // the post's own written text, newlines preserved, never truncated imageUrl: string | null; // null for a pure video or text-only post videoUrl: string | null; // set only when the post IS a video postedDate: string | null; // a real ISO timestamp, to the millisecond likeCount: number | null; commentCount: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getPostCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getPost("7458381061027323905");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getPost("7458381061027323905"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getPost \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"urlOrId":"7458381061027323905"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getPost("7458381061027323905");getProfileReturns the public professional record of one person from their profile URL.Arguments
Name Type Required urlOrSlugstringYes Returns
LinkedinProfileinterface LinkedinProfile { id: string; // the URL slug, e.g. "williamhgates" url: string; name: string; // The page's description as LinkedIn serves it to a logged-out reader: the opening // of the member's About text (for some, a headline-like line), often cut with "…". // The headline under the name is not served anonymously. headline: string | null; badge: string | null; // a status badge ("Creator", "Top Voice"), where the member has one location: string | null; country: string | null; // ISO 3166 alpha-2, e.g. "US" photoUrl: string | null; followers: number | null; connections: number | null; // first-degree connections, where the page shows them (capped at 500) currentTitle: string | null; // "position" only when LinkedIn publishes the current position title. A masked // position remains null; the anonymous headline is not promoted into a current title. currentTitleSource: "position" | "headline" | null; currentEmployer: string | null; currentEmployerUrl: string | null; positions: LinkedinProfilePosition[]; // every position, newest first education: LinkedinProfileSchool[]; // schools only pastOrganizations: LinkedinProfileSchool[]; // past employers and board seats, not schools languages: string[]; // True when LinkedIn hid a title, employer or the headline from this logged-out // read. Those come back null or are left out, never as asterisks or blank rows, // so a null with masked:true means "hidden", not "the member left it blank". masked: boolean; // "anonymous": the full public page. "preview": a thinner link-preview read, every // title withheld. "signed-in": read through YOUR LinkedIn sign-in, used for a // masked member when you have one live, then badge, followers and languages are // null/empty, and past employers are in positions (with an endDate). readAs: "anonymous" | "preview" | "signed-in"; } interface LinkedinProfilePosition { title: string | null; company: string | null; companyUrl: string | null; // feeds straight into getCompany location: string | null; startDate: string | null; endDate: string | null; } interface LinkedinProfileSchool { name: string; url: string | null; startDate: string | null; endDate: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getProfileCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getProfile("williamhgates");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getProfile("williamhgates"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getProfile \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"urlOrSlug":"williamhgates"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getProfile("williamhgates");getProfileDetailsReturns one member's full profile as a signed-in member sees it.Arguments
Name Type Required profilestringYes Returns
LinkedinMemberProfileinterface LinkedinMember { id: string | null; // profile id publicIdentifier: string | null; // URL slug, feeds getProfile / getProfileDetails url: string | null; name: string; firstName: string | null; lastName: string | null; headline: string | null; photoUrl: string | null; } interface LinkedinMemberProfile extends LinkedinMember { summary: string | null; location: string | null; countryCode: string | null; industry: string | null; premium: boolean; influencer: boolean; creator: boolean; positions: { title: string | null; company: string | null; companyUrl: string | null; startDate: string | null; endDate: string | null; description: string | null; location: string | null }[]; education: { school: string | null; schoolUrl: string | null; degree: string | null; fieldOfStudy: string | null; startDate: string | null; endDate: string | null }[]; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getProfileDetailsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getProfileDetails("williamhgates");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getProfileDetails("williamhgates"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getProfileDetails \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"profile":"williamhgates"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getProfileDetails("williamhgates");getProfileViewsReturns "who viewed your profile" for the caller: the view count LinkedIn reports and the viewers it names.Arguments
None.
Returns
{ views: number | null; viewers: LinkedinMember[] }interface LinkedinMember { id: string | null; // profile id publicIdentifier: string | null; // URL slug, feeds getProfile / getProfileDetails url: string | null; name: string; firstName: string | null; lastName: string | null; headline: string | null; photoUrl: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getProfileViewsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getProfileViews();import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getProfileViews())curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getProfileViews \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getProfileViews();getSchoolReturns a school or university's public LinkedIn page from its URL.Arguments
Name Type Required urlOrHandlestringYes Returns
LinkedinSchoolinterface LinkedinSchool { id: string; // the handle, e.g. "harvard-university", pass it straight back to getSchool url: string; name: string; description: string | null; website: string | null; industry: string | null; // e.g. "Higher Education" size: string | null; // LinkedIn's own band, e.g. "10,001+ employees" alumniCount: number | null; // member profiles naming this school, "the alumni count LinkedIn reports" headquarters: string | null; address: LinkedinCompanyAddress | null; organizationType: string | null; // e.g. "Educational" foundedYear: number | null; specialties: string[]; logoUrl: string | null; } interface LinkedinCompanyAddress { streetAddress: string | null; addressLocality: string | null; addressRegion: string | null; postalCode: string | null; addressCountry: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/getSchoolCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.getSchool("harvard-university");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.getSchool("harvard-university"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/getSchool \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"urlOrHandle":"harvard-university"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.getSchool("harvard-university");listAppliedJobsLists the jobs the caller has applied to on LinkedIn, newest first.Arguments
Name Type Required input{ start?: number }No Returns
{ jobs: LinkedinTrackedJob[]; total: number | null; start: number; nextStart: number | null }interface LinkedinTrackedJob { id: string | null; // posting id, feeds getJob url: string | null; title: string; company: string | null; location: string | null; status: string | null; // LinkedIn's card line, verbatim: "Saved 2d ago", "Application viewed" }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listAppliedJobsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listAppliedJobs({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listAppliedJobs({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listAppliedJobs \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listAppliedJobs({});listCompanyEmployeesLists people who give a company as their current employer.Arguments
Name Type Required inputstring | { company: string; keywords?: string; title?: string; start?: number }Yes Returns
LinkedinSearchPage<LinkedinSearchMember> & { companyId: string }interface LinkedinSearchMember { id: string | null; publicIdentifier: string | null; url: string | null; name: string; // "LinkedIn Member" where LinkedIn hides the name headline: string | null; location: string | null; degree: string | null; // "1st" | "2nd" | "3rd+" snippet: string | null; } // Paged results carry { start, nextStart }, pass nextStart back as start; null means the last page. interface LinkedinSearchPage<T> { results: T[]; total: number | null; start: number; nextStart: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listCompanyEmployeesCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listCompanyEmployees("stripe");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listCompanyEmployees("stripe"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listCompanyEmployees \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"stripe"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listCompanyEmployees("stripe");listCompanyJobsReturns the open roles a single named company is currently advertising, as a list of postings with title, location, employer and posting date.Arguments
Name Type Required companyUrlOrHandlestringYes query.keywordsstringNo query.locationstringNo query.geoIdstringLinkedIn's numeric region id, where a place name is ambiguous.No query.postedWithin"24h" | "week" | "month"No query.limitnumberDefault 10, capped at 1000.No Returns
LinkedinJobSearchResult[]interface LinkedinJobSearchResult { id: string; // the posting id, pass it straight to getJob url: string; title: string; company: string | null; companyUrl: string | null; location: string | null; postedDate: string | null; isNew: boolean; hiringFlag: string | null; // e.g. "Actively Hiring", where the card shows one }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listCompanyJobsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listCompanyJobs("microsoft");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listCompanyJobs("microsoft"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listCompanyJobs \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"companyUrlOrHandle":"microsoft"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listCompanyJobs("microsoft");listCompanyPostsLists a company page's recent posts, as LinkedIn itself samples them on the company page.Arguments
Name Type Required companyUrlOrHandlestringYes Returns
LinkedinPost[]interface LinkedinPost { id: string; // the numeric activity id, pass it straight back to getPost url: string; authorName: string | null; authorUrl: string | null; text: string; // the post's own written text, newlines preserved, never truncated imageUrl: string | null; // null for a pure video or text-only post videoUrl: string | null; // set only when the post IS a video postedDate: string | null; // a real ISO timestamp, to the millisecond likeCount: number | null; commentCount: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listCompanyPostsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listCompanyPosts("microsoft");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listCompanyPosts("microsoft"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listCompanyPosts \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"companyUrlOrHandle":"microsoft"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listCompanyPosts("microsoft");listConnectionsLists the caller's first-degree connections, most recently connected first, with each person's name, headline, profile URL and when they connected.…Arguments
Name Type Required input{ start?: number; count?: number }No Returns
{ connections: LinkedinConnection[]; start: number; nextStart: number | null }interface LinkedinMember { id: string | null; // profile id publicIdentifier: string | null; // URL slug, feeds getProfile / getProfileDetails url: string | null; name: string; firstName: string | null; lastName: string | null; headline: string | null; photoUrl: string | null; } interface LinkedinConnection extends LinkedinMember { connectedAt: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listConnectionsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listConnections({ count: 5 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listConnections({"count": 5}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listConnections \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{"count":5}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listConnections({ count: 5 });listConversationsLists the caller's LinkedIn message threads, most recent first, with the other participants, unread count and the latest message in each.Arguments
None.
Returns
{ conversations: LinkedinConversation[] }interface LinkedinMember { id: string | null; // profile id publicIdentifier: string | null; // URL slug, feeds getProfile / getProfileDetails url: string | null; name: string; firstName: string | null; lastName: string | null; headline: string | null; photoUrl: string | null; } interface LinkedinMessage { id: string | null; sender: LinkedinMember | null; text: string | null; sentAt: string | null; } interface LinkedinConversation { id: string; // what getConversation takes urn: string; title: string | null; participants: LinkedinMember[]; unreadCount: number; lastActivityAt: string | null; lastMessage: LinkedinMessage | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listConversationsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listConversations();import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listConversations())curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listConversations \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listConversations();listFollowingLists the members, companies and newsletters the caller follows, with each one's name, URL and kind. count up to 100 per page (default 20).Arguments
Name Type Required input{ start?: number; count?: number }No Returns
{ following: LinkedinFollowedEntity[]; start: number; nextStart: number | null }interface LinkedinFollowedEntity { id: string | null; name: string | null; url: string | null; kind: "member" | "company" | "newsletter" | "unknown"; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listFollowingCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listFollowing({ count: 5 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listFollowing({"count": 5}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listFollowing \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{"count":5}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listFollowing({ count: 5 });listInvitationsLists the connection invitations the caller has received and not yet answered.Arguments
Name Type Required input{ start?: number; count?: number }No Returns
{ invitations: LinkedinInvitation[]; start: number; nextStart: number | null }interface LinkedinMember { id: string | null; // profile id publicIdentifier: string | null; // URL slug, feeds getProfile / getProfileDetails url: string | null; name: string; firstName: string | null; lastName: string | null; headline: string | null; photoUrl: string | null; } interface LinkedinInvitation { id: string | null; sharedSecret: string | null; member: LinkedinMember | null; message: string | null; sentAt: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listInvitationsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listInvitations({ count: 5 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listInvitations({"count": 5}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listInvitations \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{"count":5}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listInvitations({ count: 5 });listMemberPostsLists a member's own recent posts and reposts, as LinkedIn itself samples them on their public profile page.Arguments
Name Type Required profileUrlOrSlugstringYes Returns
LinkedinPost[]interface LinkedinPost { id: string; // the numeric activity id, pass it straight back to getPost url: string; authorName: string | null; authorUrl: string | null; text: string; // the post's own written text, newlines preserved, never truncated imageUrl: string | null; // null for a pure video or text-only post videoUrl: string | null; // set only when the post IS a video postedDate: string | null; // a real ISO timestamp, to the millisecond likeCount: number | null; commentCount: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listMemberPostsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listMemberPosts("williamhgates");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listMemberPosts("williamhgates"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listMemberPosts \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"profileUrlOrSlug":"williamhgates"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listMemberPosts("williamhgates");listMyGroupsLists the groups the caller belongs to.Arguments
Name Type Required input{ start?: number; count?: number }No Returns
{ groups: LinkedinGroupDetail[]; start: number; nextStart: number | null }interface LinkedinGroupDetail { id: string | null; url: string | null; name: string; description: string | null; members: string | null; // LinkedIn's member line, verbatim, "12K members", where the entity carries one }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listMyGroupsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listMyGroups({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listMyGroups({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listMyGroups \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listMyGroups({});listNotificationsLists the caller's LinkedIn notifications, newest first.Arguments
Name Type Required input{ start?: number; count?: number }No Returns
{ notifications: LinkedinNotification[]; start: number; nextStart: number | null }interface LinkedinNotification { id: string | null; text: string | null; url: string | null; occurredAt: string | null; read: boolean | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listNotificationsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listNotifications({ count: 5 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listNotifications({"count": 5}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listNotifications \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{"count":5}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listNotifications({ count: 5 });listPostCommentsLists the comments LinkedIn server-renders on one public post's page.Arguments
Name Type Required urlOrIdstringYes Returns
LinkedinPostComment[]interface LinkedinPostComment { authorName: string | null; authorUrl: string | null; text: string; // includes an @mention LinkedIn renders inline, where the commenter wrote one postedRelative: string | null; // the site's own phrase, e.g. "5mo", no absolute timestamp is published reactionCount: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listPostCommentsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listPostComments("7458381061027323905");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listPostComments("7458381061027323905"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listPostComments \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"urlOrId":"7458381061027323905"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listPostComments("7458381061027323905");listSavedJobsLists the jobs the caller has saved, newest first.Arguments
Name Type Required input{ start?: number }No Returns
{ jobs: LinkedinTrackedJob[]; total: number | null; start: number; nextStart: number | null }interface LinkedinTrackedJob { id: string | null; // posting id, feeds getJob url: string | null; title: string; company: string | null; location: string | null; status: string | null; // LinkedIn's card line, verbatim: "Saved 2d ago", "Application viewed" }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listSavedJobsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listSavedJobs({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listSavedJobs({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listSavedJobs \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listSavedJobs({});listSavedPostsLists the posts and articles the caller has saved, newest first.Arguments
Name Type Required input{ start?: number }No Returns
{ posts: LinkedinSavedPost[]; total: number | null; start: number; nextStart: number | null }interface LinkedinSavedPost { urn: string | null; url: string | null; author: string | null; authorHeadline: string | null; text: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listSavedPostsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listSavedPosts({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listSavedPosts({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listSavedPosts \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listSavedPosts({});listSentInvitationsLists the connection invitations the caller has sent that are still pending.Arguments
Name Type Required input{ start?: number; count?: number }No Returns
{ invitations: LinkedinInvitation[]; start: number; nextStart: number | null }interface LinkedinMember { id: string | null; // profile id publicIdentifier: string | null; // URL slug, feeds getProfile / getProfileDetails url: string | null; name: string; firstName: string | null; lastName: string | null; headline: string | null; photoUrl: string | null; } interface LinkedinInvitation { id: string | null; sharedSecret: string | null; member: LinkedinMember | null; message: string | null; sentAt: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listSentInvitationsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listSentInvitations({ count: 5 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listSentInvitations({"count": 5}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listSentInvitations \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{"count":5}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listSentInvitations({ count: 5 });listSuggestedConnectionsLists the people LinkedIn suggests the caller connect with ("People you may know").Arguments
Name Type Required input{ start?: number; count?: number }No Returns
{ suggestions: LinkedinSuggestedConnection[]; start: number; nextStart: number | null }interface LinkedinMember { id: string | null; // profile id publicIdentifier: string | null; // URL slug, feeds getProfile / getProfileDetails url: string | null; name: string; firstName: string | null; lastName: string | null; headline: string | null; photoUrl: string | null; } interface LinkedinSuggestedConnection extends LinkedinMember { reason: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/listSuggestedConnectionsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.listSuggestedConnections({ count: 5 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.listSuggestedConnections({"count": 5}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/listSuggestedConnections \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{"count":5}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.listSuggestedConnections({ count: 5 });searchCompaniesSearches LinkedIn's companies by name or keyword and returns 10 ranked companies per page with each one's handle, numeric id, industry, location and…Arguments
Name Type Required inputstring | { keywords: string; start?: number }Yes Returns
LinkedinSearchPage<LinkedinSearchCompany>interface LinkedinSearchCompany { id: string | null; // numeric, listCompanyEmployees / searchMembers({ currentCompany }) handle: string | null; // what getCompany takes url: string | null; name: string; industry: string | null; location: string | null; followers: string | null; // e.g. "1M followers" } // Paged results carry { start, nextStart }, pass nextStart back as start; null means the last page. interface LinkedinSearchPage<T> { results: T[]; total: number | null; start: number; nextStart: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/searchCompaniesCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.searchCompanies("stripe");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.searchCompanies("stripe"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/searchCompanies \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"stripe"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.searchCompanies("stripe");searchEventsSearches LinkedIn events by keyword, 10 per page.Arguments
Name Type Required inputstring | { keywords: string; start?: number }Yes Returns
LinkedinSearchPage<LinkedinSearchEvent>interface LinkedinSearchEvent { id: string | null; // feeds getEvent url: string | null; name: string; organizer: string | null; when: string | null; // LinkedIn's own time/format line, verbatim } // Paged results carry { start, nextStart }, pass nextStart back as start; null means the last page. interface LinkedinSearchPage<T> { results: T[]; total: number | null; start: number; nextStart: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/searchEventsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.searchEvents("product management");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.searchEvents("product management"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/searchEvents \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"product management"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.searchEvents("product management");searchGroupsSearches LinkedIn groups by keyword, 10 per page.Arguments
Name Type Required inputstring | { keywords: string; start?: number }Yes Returns
LinkedinSearchPage<LinkedinSearchGroup>interface LinkedinSearchGroup { id: string | null; // numeric group id, feeds getGroup / joinGroup url: string | null; name: string; members: string | null; // LinkedIn's line, verbatim: "12K members" description: string | null; } // Paged results carry { start, nextStart }, pass nextStart back as start; null means the last page. interface LinkedinSearchPage<T> { results: T[]; total: number | null; start: number; nextStart: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/searchGroupsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.searchGroups("product management");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.searchGroups("product management"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/searchGroups \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"product management"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.searchGroups("product management");searchJobsReturns the job postings matching a search.Arguments
Name Type Required queryLinkedinJobSearchQuery | stringYes interface LinkedinJobSearchQuery { keywords?: string; location?: string; geoId?: string; // LinkedIn's numeric region id, where a place name is ambiguous postedWithin?: "24h" | "week" | "month"; limit?: number; // default 10, capped at 1000 }Returns
LinkedinJobSearchResult[]interface LinkedinJobSearchResult { id: string; // the posting id, pass it straight to getJob url: string; title: string; company: string | null; companyUrl: string | null; location: string | null; postedDate: string | null; isNew: boolean; hiringFlag: string | null; // e.g. "Actively Hiring", where the card shows one }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/searchJobsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.searchJobs({ keywords: "software engineer", location: "United States", limit: 20 });import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.searchJobs({ "keywords": "software engineer", "location": "United States", "limit": 20 }))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/searchJobs \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"query":{"keywords":"software engineer","location":"United States","limit":20}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.searchJobs({ keywords: "software engineer", location: "United States", limit: 20 });searchLearningCoursesReturns LinkedIn Learning courses matching a search.Arguments
Name Type Required keywordsstringYes Returns
LinkedinLearningCourse[]interface LinkedinLearningCourse { title: string; url: string; // the course's own URL, pass it straight to getLearningCourse authorName: string | null; duration: string | null; // LinkedIn's own rendered duration, e.g. "4h 23m" viewerCount: number | null; released: string | null; // LinkedIn's own phrase, e.g. "Released Jan 25, 2023" thumbnailUrl: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/searchLearningCoursesCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.searchLearningCourses("python");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.searchLearningCourses("python"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/searchLearningCourses \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"keywords":"python"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.searchLearningCourses("python");searchMembersLinkedIn's own people search, run as the caller: keywords plus optional filters.Arguments
Name Type Required inputstring | { keywords: string; currentCompany?: string | string[]; title?: string; location?: string; network?: string | string[]; start?: number }Yes Returns
LinkedinSearchPage<LinkedinSearchMember>interface LinkedinSearchMember { id: string | null; publicIdentifier: string | null; url: string | null; name: string; // "LinkedIn Member" where LinkedIn hides the name headline: string | null; location: string | null; degree: string | null; // "1st" | "2nd" | "3rd+" snippet: string | null; } // Paged results carry { start, nextStart }, pass nextStart back as start; null means the last page. interface LinkedinSearchPage<T> { results: T[]; total: number | null; start: number; nextStart: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/searchMembersCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.searchMembers("satya nadella");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.searchMembers("satya nadella"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/searchMembers \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"satya nadella"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.searchMembers("satya nadella");searchPeopleFinds LinkedIn members by name through LinkedIn's own public people directory and returns each match's full public profile, plus every other person…Arguments
Name Type Required querystring | {query?: string, firstName?: string, lastName?: string, limit?: number}Yes Returns
LinkedinPeopleSearchinterface LinkedinPeopleSearch { profiles: LinkedinProfile[]; // One line per candidate the index found and getProfile could NOT read. Empty // on a clean search. A short `profiles` with an empty `warnings` means the // index knew of that many people; a short one with warnings means some // refused us, read this before treating the list as everyone by that name. warnings: string[]; } interface LinkedinProfile { id: string; // the URL slug, e.g. "williamhgates" url: string; name: string; // The page's description as LinkedIn serves it to a logged-out reader: the opening // of the member's About text (for some, a headline-like line), often cut with "…". // The headline under the name is not served anonymously. headline: string | null; badge: string | null; // a status badge ("Creator", "Top Voice"), where the member has one location: string | null; country: string | null; // ISO 3166 alpha-2, e.g. "US" photoUrl: string | null; followers: number | null; connections: number | null; // first-degree connections, where the page shows them (capped at 500) currentTitle: string | null; // "position" only when LinkedIn publishes the current position title. A masked // position remains null; the anonymous headline is not promoted into a current title. currentTitleSource: "position" | "headline" | null; currentEmployer: string | null; currentEmployerUrl: string | null; positions: LinkedinProfilePosition[]; // every position, newest first education: LinkedinProfileSchool[]; // schools only pastOrganizations: LinkedinProfileSchool[]; // past employers and board seats, not schools languages: string[]; // True when LinkedIn hid a title, employer or the headline from this logged-out // read. Those come back null or are left out, never as asterisks or blank rows, // so a null with masked:true means "hidden", not "the member left it blank". masked: boolean; // "anonymous": the full public page. "preview": a thinner link-preview read, every // title withheld. "signed-in": read through YOUR LinkedIn sign-in, used for a // masked member when you have one live, then badge, followers and languages are // null/empty, and past employers are in positions (with an endDate). readAs: "anonymous" | "preview" | "signed-in"; } interface LinkedinProfilePosition { title: string | null; company: string | null; companyUrl: string | null; // feeds straight into getCompany location: string | null; startDate: string | null; endDate: string | null; } interface LinkedinProfileSchool { name: string; url: string | null; startDate: string | null; endDate: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/searchPeopleCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.searchPeople("Bill Gates Microsoft");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.searchPeople("Bill Gates Microsoft"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/searchPeople \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"query":"Bill Gates Microsoft"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.searchPeople("Bill Gates Microsoft");searchPostsSearches LinkedIn posts by keyword and returns 10 per page with author, text, how long ago each was posted, its reaction, comment and repost counts…Arguments
Name Type Required inputstring | { keywords: string; start?: number }Yes Returns
LinkedinSearchPage<LinkedinFeedPost>interface LinkedinFeedPost { activityUrn: string | null; url: string | null; author: { name: string | null; headline: string | null; url: string | null }; text: string | null; postedAgo: string | null; // e.g. "2d" reactions: number | null; comments: number | null; reposts: number | null; promoted: boolean; } // Paged results carry { start, nextStart }, pass nextStart back as start; null means the last page. interface LinkedinSearchPage<T> { results: T[]; total: number | null; start: number; nextStart: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/searchPostsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.searchPosts("agentic browser");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.searchPosts("agentic browser"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/searchPosts \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"agentic browser"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.searchPosts("agentic browser");searchSchoolsSearches LinkedIn schools and universities by name, 10 per page.Arguments
Name Type Required inputstring | { keywords: string; start?: number }Yes Returns
LinkedinSearchPage<LinkedinSearchSchool>interface LinkedinSearchSchool { handle: string | null; // feeds getSchool url: string | null; name: string; location: string | null; } // Paged results carry { start, nextStart }, pass nextStart back as start; null means the last page. interface LinkedinSearchPage<T> { results: T[]; total: number | null; start: number; nextStart: number | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/searchSchoolsCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.searchSchools("stanford");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.searchSchools("stanford"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/searchSchools \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"stanford"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.searchSchools("stanford");searchServiceProvidersReturns the LinkedIn members who sell a given professional service.Arguments
Name Type Required categorystringYes Returns
LinkedinServiceProvider[]interface LinkedinServiceProvider { name: string; url: string | null; // the member's profile URL, feeds getProfile / getProfileDetails services: string[]; // the services this member listed on their card location: string | null; summary: string | null; // the card's own pitch, where the member wrote one photoUrl: string | null; // null for LinkedIn's own placeholder avatar }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/searchServiceProvidersCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.searchServiceProviders("ios-developers");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.searchServiceProviders("ios-developers"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/searchServiceProviders \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"category":"ios-developers"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.searchServiceProviders("ios-developers");
acceptInvitationAccepts a connection invitation the signed-in caller received, by the id and sharedSecret listInvitations returned.Arguments
Name Type Required input{ invitation: string; sharedSecret: string }Yes Returns
{ accepted: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/acceptInvitationCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.acceptInvitation({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.acceptInvitation({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/acceptInvitation \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.acceptInvitation({});addProfileSkillAdds one skill to the signed-in caller's own LinkedIn profile.Arguments
Name Type Required inputstring | { skill: string }Yes Returns
{ added: string; id: string | null }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/addProfileSkillCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.addProfileSkill("<input>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.addProfileSkill("<input>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/addProfileSkill \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"<input>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.addProfileSkill("<input>");applyToJobSubmits an Easy Apply application to a job posting as the signed-in caller, using the profile, contact details and resume already on their account…Arguments
Name Type Required input{ job: string; answers?: Record<string, string | number>; submit?: boolean }Yes Returns
{ submitted: boolean; unanswered: string[]; questions: string[] }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/applyToJobCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.applyToJob({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.applyToJob({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/applyToJob \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.applyToJob({});attendEventRSVPs the signed-in caller to a LinkedIn event (the Attend button), or withdraws the RSVP when attend: false.Arguments
Name Type Required inputstring | { event: string; attend?: boolean }Yes Returns
{ attending: boolean }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/attendEventCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.attendEvent("<input>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.attendEvent("<input>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/attendEvent \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"<input>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.attendEvent("<input>");commentOnPostComments on a post as the signed-in caller.Arguments
Name Type Required input{ post: string; text: string }Yes Returns
LinkedinPostResultinterface LinkedinPostResult { id: string | null; // feeds deletePost / deleteComment / commentOnPost / reactToPost, null when unread, not when the write failed url: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/commentOnPostCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.commentOnPost({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.commentOnPost({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/commentOnPost \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.commentOnPost({});createGroupPostPublishes a text post inside a LinkedIn group the signed-in caller belongs to. group is a group URL or the numeric id searchGroups/listMyGroups…Arguments
Name Type Required input{ group: string; text: string }Yes Returns
LinkedinPostResultinterface LinkedinPostResult { id: string | null; // feeds deletePost / deleteComment / commentOnPost / reactToPost, null when unread, not when the write failed url: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/createGroupPostCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.createGroupPost({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.createGroupPost({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/createGroupPost \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.createGroupPost({});createPostPublishes a text post to the signed-in caller's feed, visible to anyone or to connections only.Arguments
Name Type Required input{ text: string; visibility?: "public" | "connections" }Yes Returns
LinkedinPostResultinterface LinkedinPostResult { id: string | null; // feeds deletePost / deleteComment / commentOnPost / reactToPost, null when unread, not when the write failed url: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/createPostCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.createPost({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.createPost({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/createPost \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.createPost({});deleteCommentDeletes one of the signed-in caller's own comments.Arguments
Name Type Required commentstringYes Returns
{ deleted: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/deleteCommentCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.deleteComment("<comment>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.deleteComment("<comment>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/deleteComment \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"comment":"<comment>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.deleteComment("<comment>");deletePostDeletes one of the signed-in caller's own posts or reposts.Arguments
Name Type Required poststringYes Returns
{ deleted: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/deletePostCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.deletePost("<post>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.deletePost("<post>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/deletePost \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"post":"<post>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.deletePost("<post>");followCompanyFollows or unfollows a company page as the signed-in caller. company is the numeric companyId getCompany, searchCompanies or listCompanyEmployees…Arguments
Name Type Required input{ company: string; follow?: boolean }Yes Returns
{ following: boolean }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/followCompanyCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.followCompany({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.followCompany({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/followCompany \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.followCompany({});followMemberFollows or unfollows a member as the signed-in caller, so their posts appear in the caller's feed without a connection. member is the numeric profile…Arguments
Name Type Required input{ member: string; follow?: boolean }Yes Returns
{ following: boolean }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/followMemberCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.followMember({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.followMember({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/followMember \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.followMember({});ignoreInvitationIgnores a connection invitation the signed-in caller received, without telling the sender.Arguments
Name Type Required input{ invitation: string; sharedSecret: string }Yes Returns
{ ignored: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/ignoreInvitationCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.ignoreInvitation({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.ignoreInvitation({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/ignoreInvitation \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.ignoreInvitation({});joinGroupJoins a LinkedIn group as the signed-in caller, or asks to join one that needs approval.Arguments
Name Type Required groupstring | { group: string }Yes Returns
{ joined: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/joinGroupCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.joinGroup("<group>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.joinGroup("<group>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/joinGroup \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"group":"<group>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.joinGroup("<group>");leaveGroupLeaves a LinkedIn group the signed-in caller belongs to.Arguments
Name Type Required groupstring | { group: string }Yes Returns
{ left: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/leaveGroupCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.leaveGroup("<group>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.leaveGroup("<group>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/leaveGroup \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"group":"<group>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.leaveGroup("<group>");reactToPostReacts to a post as the signed-in caller.Arguments
Name Type Required input{ post: string; reaction?: "LIKE" | "PRAISE" | "APPRECIATION" | "EMPATHY" | "INTEREST" | "ENTERTAINMENT" }Yes Returns
LinkedinReactToPostResultinterface LinkedinReactToPostResult { reacted: true; reaction: "LIKE" | "PRAISE" | "APPRECIATION" | "EMPATHY" | "INTEREST" | "ENTERTAINMENT"; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/reactToPostCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.reactToPost({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.reactToPost({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/reactToPost \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.reactToPost({});removeConnectionRemoves a member from the signed-in caller's connections.Arguments
Name Type Required memberstringYes Returns
{ removed: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/removeConnectionCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.removeConnection("<member>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.removeConnection("<member>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/removeConnection \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"member":"<member>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.removeConnection("<member>");replyToCommentReplies under one comment on a LinkedIn post as the signed-in caller, threaded.Arguments
Name Type Required input{ comment: string; text: string }Yes Returns
LinkedinPostResultinterface LinkedinPostResult { id: string | null; // feeds deletePost / deleteComment / commentOnPost / reactToPost, null when unread, not when the write failed url: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/replyToCommentCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.replyToComment({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.replyToComment({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/replyToComment \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.replyToComment({});repostPostReposts a post to the signed-in caller's feed, with or without their own text on top.Arguments
Name Type Required input{ post: string; text?: string }Yes Returns
LinkedinPostResultinterface LinkedinPostResult { id: string | null; // feeds deletePost / deleteComment / commentOnPost / reactToPost, null when unread, not when the write failed url: string | null; }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/repostPostCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.repostPost({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.repostPost({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/repostPost \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.repostPost({});saveJobSaves a job posting to the signed-in caller's saved jobs, or unsaves it.Arguments
Name Type Required inputstring | { job: string; save?: boolean }Yes Returns
{ saved: boolean }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/saveJobCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.saveJob("<input>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.saveJob("<input>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/saveJob \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"<input>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.saveJob("<input>");savePostSaves a post to the signed-in caller's saved items, or unsaves it.Arguments
Name Type Required input{ post: string; save?: boolean }Yes Returns
{ saved: boolean }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/savePostCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.savePost({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.savePost({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/savePost \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.savePost({});sendConnectionRequestSends a connection invitation from the signed-in caller to a member, with an optional note of up to 300 characters. member is the numeric profile id…Arguments
Name Type Required input{ member: string; message?: string }Yes Returns
{ sent: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/sendConnectionRequestCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.sendConnectionRequest({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.sendConnectionRequest({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/sendConnectionRequest \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.sendConnectionRequest({});sendMessageSends a LinkedIn message as the signed-in caller.Arguments
Name Type Required input{ conversation?: string; member?: string; text: string }Yes Returns
{ sent: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/sendMessageCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.sendMessage({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.sendMessage({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/sendMessage \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.sendMessage({});setProfilePhotoReplaces the signed-in caller's profile photo with an image from a URL or uploaded file.Arguments
Name Type Required input{ base64: string; mimeType: "image/jpeg" | "image/png" } | { url: string }Yes Returns
{ updated: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/setProfilePhotoCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.setProfilePhoto({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.setProfilePhoto({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/setProfilePhoto \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.setProfilePhoto({});subscribeToNewsletterSubscribes the signed-in caller to a LinkedIn newsletter, or unsubscribes when subscribe: false.Arguments
Name Type Required inputstring | { newsletter: string; subscribe?: boolean }Yes Returns
{ subscribed: boolean }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/subscribeToNewsletterCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.subscribeToNewsletter("<input>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.subscribeToNewsletter("<input>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/subscribeToNewsletter \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":"<input>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.subscribeToNewsletter("<input>");updateProfileEdits the signed-in caller's own profile headline and About text.Arguments
Name Type Required input{ headline?: string; about?: string }Yes Returns
{ updated: string[] }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/updateProfileCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.updateProfile({});import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.updateProfile({}))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/updateProfile \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"input":{}}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.updateProfile({});withdrawInvitationWithdraws a connection invitation the signed-in caller sent and is still pending, by the id listSentInvitations returned.Arguments
Name Type Required invitationstringYes Returns
{ withdrawn: true }HTTP endpoint
POST https://api.bowmark.ai/v1/sites/linkedin/withdrawInvitationCall it
import { bowmark } from "@bowmark/web"; const result = await bowmark.providers.linkedin.withdrawInvitation("<invitation>");import asyncio from bowmark_web import bowmark result = asyncio.run(bowmark.providers.linkedin.withdrawInvitation("<invitation>"))curl -X POST https://api.bowmark.ai/v1/sites/linkedin/withdrawInvitation \ -H "Authorization: Bearer $BOWMARK_API_KEY" \ -H "Content-Type: application/json" \ -d '{"invitation":"<invitation>"}'// The body of a run: the MCP run tool, or POST /v1/run return await bowmark.providers.linkedin.withdrawInvitation("<invitation>");
Use it from code
- Node
npm i @bowmark/web - Python
pip install bowmark-web - HTTP
POST /v1/sites/linkedin/<function> - OpenAPI
/v1/sites/linkedin/openapi.json