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.

Functions
66
Sign-in
For account actions
Works with
MCP, HTTP, Node, Python

Connect

Just LinkedIn

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/linkedin
Every site

One MCP server for LinkedIn and every other site Bowmark covers. Your agent looks up what it needs and calls it.

https://api.bowmark.ai/mcp
Set it up in your client

Both 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.

Read 40
  • getArticleReturns one long-form LinkedIn article or newsletter issue from its /pulse/ URL.

    Arguments

    NameTypeRequired
    urlOrSlugstringYes

    Returns LinkedinArticle

    interface 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/getArticle

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    urlOrHandlestringYes

    Returns LinkedinCompany

    interface 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/getCompany

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getCompany("<urlOrHandle>");
  • getConversationReads one LinkedIn message thread in order, oldest first.

    Arguments

    NameTypeRequired
    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/getConversation

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getConversation("2-bm9uZXhpc3RlbnRfY2FuYXJ5XzEwMA==");
  • getEventReturns one LinkedIn event by its URL or numeric id (from searchEvents).

    Arguments

    NameTypeRequired
    inputstring | { event: string }Yes

    Returns LinkedinEventDetail

    interface 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/getEvent

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getEvent("7250000000000000000");
  • getGroupReturns one LinkedIn group by its URL or numeric id (from searchGroups or listMyGroups).

    Arguments

    NameTypeRequired
    inputstring | { group: string }Yes

    Returns LinkedinGroupDetail

    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/getGroup

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    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/getHomeFeed

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getHomeFeed({ count: 3 });
  • getJobReturns one job posting in full from its posting URL.

    Arguments

    NameTypeRequired
    urlstringYes

    Returns LinkedinJobPosting

    interface 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/getJob

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getJob("<url>");
  • getLearningCourseReturns one LinkedIn Learning course in full.

    Arguments

    NameTypeRequired
    urlOrSlugstringYes

    Returns LinkedinLearningCourseDetail

    interface 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/getLearningCourse

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getLearningCourse("python-essential-training-18764650");
  • getMyProfileReturns the signed-in caller's own LinkedIn member record.

    Arguments

    None.

    Returns LinkedinMe

    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 LinkedinMe extends LinkedinMember { premium: boolean; }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/getMyProfile

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getMyProfile();
  • getPostReads one public LinkedIn post.

    Arguments

    NameTypeRequired
    urlOrIdstringYes

    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/getPost

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getPost("7458381061027323905");
  • getProfileReturns the public professional record of one person from their profile URL.

    Arguments

    NameTypeRequired
    urlOrSlugstringYes

    Returns LinkedinProfile

    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/getProfile

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getProfile("williamhgates");
  • getProfileDetailsReturns one member's full profile as a signed-in member sees it.

    Arguments

    NameTypeRequired
    profilestringYes

    Returns LinkedinMemberProfile

    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 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/getProfileDetails

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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/getProfileViews

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getProfileViews();
  • getSchoolReturns a school or university's public LinkedIn page from its URL.

    Arguments

    NameTypeRequired
    urlOrHandlestringYes

    Returns LinkedinSchool

    interface 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/getSchool

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.getSchool("harvard-university");
  • listAppliedJobsLists the jobs the caller has applied to on LinkedIn, newest first.

    Arguments

    NameTypeRequired
    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/listAppliedJobs

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.listAppliedJobs({});
  • listCompanyEmployeesLists people who give a company as their current employer.

    Arguments

    NameTypeRequired
    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/listCompanyEmployees

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    companyUrlOrHandlestringYes
    query.keywordsstringNo
    query.locationstringNo
    query.geoIdstring
    LinkedIn's numeric region id, where a place name is ambiguous.
    No
    query.postedWithin"24h" | "week" | "month"No
    query.limitnumber
    Default 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/listCompanyJobs

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.listCompanyJobs("microsoft");
  • listCompanyPostsLists a company page's recent posts, as LinkedIn itself samples them on the company page.

    Arguments

    NameTypeRequired
    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/listCompanyPosts

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    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/listConnections

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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/listConversations

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    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/listFollowing

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.listFollowing({ count: 5 });
  • listInvitationsLists the connection invitations the caller has received and not yet answered.

    Arguments

    NameTypeRequired
    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/listInvitations

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    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/listMemberPosts

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.listMemberPosts("williamhgates");
  • listMyGroupsLists the groups the caller belongs to.

    Arguments

    NameTypeRequired
    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/listMyGroups

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.listMyGroups({});
  • listNotificationsLists the caller's LinkedIn notifications, newest first.

    Arguments

    NameTypeRequired
    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/listNotifications

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.listNotifications({ count: 5 });
  • listPostCommentsLists the comments LinkedIn server-renders on one public post's page.

    Arguments

    NameTypeRequired
    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/listPostComments

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.listPostComments("7458381061027323905");
  • listSavedJobsLists the jobs the caller has saved, newest first.

    Arguments

    NameTypeRequired
    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/listSavedJobs

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.listSavedJobs({});
  • listSavedPostsLists the posts and articles the caller has saved, newest first.

    Arguments

    NameTypeRequired
    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/listSavedPosts

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.listSavedPosts({});
  • listSentInvitationsLists the connection invitations the caller has sent that are still pending.

    Arguments

    NameTypeRequired
    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/listSentInvitations

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.listSentInvitations({ count: 5 });
  • listSuggestedConnectionsLists the people LinkedIn suggests the caller connect with ("People you may know").

    Arguments

    NameTypeRequired
    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/listSuggestedConnections

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    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/searchCompanies

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.searchCompanies("stripe");
  • searchEventsSearches LinkedIn events by keyword, 10 per page.

    Arguments

    NameTypeRequired
    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/searchEvents

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.searchEvents("product management");
  • searchGroupsSearches LinkedIn groups by keyword, 10 per page.

    Arguments

    NameTypeRequired
    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/searchGroups

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.searchGroups("product management");
  • searchJobsReturns the job postings matching a search.

    Arguments

    NameTypeRequired
    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/searchJobs

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.searchJobs({
      keywords: "software engineer",
      location: "United States",
      limit: 20
    });
  • searchLearningCoursesReturns LinkedIn Learning courses matching a search.

    Arguments

    NameTypeRequired
    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/searchLearningCourses

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.searchLearningCourses("python");
  • searchMembersLinkedIn's own people search, run as the caller: keywords plus optional filters.

    Arguments

    NameTypeRequired
    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/searchMembers

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    querystring | {query?: string, firstName?: string, lastName?: string, limit?: number}Yes

    Returns LinkedinPeopleSearch

    interface 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/searchPeople

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    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/searchPosts

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.searchPosts("agentic browser");
  • searchSchoolsSearches LinkedIn schools and universities by name, 10 per page.

    Arguments

    NameTypeRequired
    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/searchSchools

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.searchSchools("stanford");
  • searchServiceProvidersReturns the LinkedIn members who sell a given professional service.

    Arguments

    NameTypeRequired
    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/searchServiceProviders

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.searchServiceProviders("ios-developers");
Act 26
  • acceptInvitationAccepts a connection invitation the signed-in caller received, by the id and sharedSecret listInvitations returned.

    Arguments

    NameTypeRequired
    input{ invitation: string; sharedSecret: string }Yes

    Returns { accepted: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/acceptInvitation

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.acceptInvitation({});
  • addProfileSkillAdds one skill to the signed-in caller's own LinkedIn profile.

    Arguments

    NameTypeRequired
    inputstring | { skill: string }Yes

    Returns { added: string; id: string | null }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/addProfileSkill

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    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/applyToJob

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    inputstring | { event: string; attend?: boolean }Yes

    Returns { attending: boolean }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/attendEvent

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.attendEvent("<input>");
  • commentOnPostComments on a post as the signed-in caller.

    Arguments

    NameTypeRequired
    input{ post: string; text: string }Yes

    Returns LinkedinPostResult

    interface 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/commentOnPost

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    input{ group: string; text: string }Yes

    Returns LinkedinPostResult

    interface 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/createGroupPost

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.createGroupPost({});
  • createPostPublishes a text post to the signed-in caller's feed, visible to anyone or to connections only.

    Arguments

    NameTypeRequired
    input{ text: string; visibility?: "public" | "connections" }Yes

    Returns LinkedinPostResult

    interface 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/createPost

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.createPost({});
  • deleteCommentDeletes one of the signed-in caller's own comments.

    Arguments

    NameTypeRequired
    commentstringYes

    Returns { deleted: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/deleteComment

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.deleteComment("<comment>");
  • deletePostDeletes one of the signed-in caller's own posts or reposts.

    Arguments

    NameTypeRequired
    poststringYes

    Returns { deleted: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/deletePost

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    input{ company: string; follow?: boolean }Yes

    Returns { following: boolean }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/followCompany

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    input{ member: string; follow?: boolean }Yes

    Returns { following: boolean }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/followMember

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.followMember({});
  • ignoreInvitationIgnores a connection invitation the signed-in caller received, without telling the sender.

    Arguments

    NameTypeRequired
    input{ invitation: string; sharedSecret: string }Yes

    Returns { ignored: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/ignoreInvitation

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.ignoreInvitation({});
  • joinGroupJoins a LinkedIn group as the signed-in caller, or asks to join one that needs approval.

    Arguments

    NameTypeRequired
    groupstring | { group: string }Yes

    Returns { joined: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/joinGroup

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.joinGroup("<group>");
  • leaveGroupLeaves a LinkedIn group the signed-in caller belongs to.

    Arguments

    NameTypeRequired
    groupstring | { group: string }Yes

    Returns { left: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/leaveGroup

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.leaveGroup("<group>");
  • reactToPostReacts to a post as the signed-in caller.

    Arguments

    NameTypeRequired
    input{ post: string; reaction?: "LIKE" | "PRAISE" | "APPRECIATION" | "EMPATHY" | "INTEREST" | "ENTERTAINMENT" }Yes

    Returns LinkedinReactToPostResult

    interface LinkedinReactToPostResult { reacted: true; reaction: "LIKE" | "PRAISE" | "APPRECIATION" | "EMPATHY" | "INTEREST" | "ENTERTAINMENT"; }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/reactToPost

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.reactToPost({});
  • removeConnectionRemoves a member from the signed-in caller's connections.

    Arguments

    NameTypeRequired
    memberstringYes

    Returns { removed: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/removeConnection

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.removeConnection("<member>");
  • replyToCommentReplies under one comment on a LinkedIn post as the signed-in caller, threaded.

    Arguments

    NameTypeRequired
    input{ comment: string; text: string }Yes

    Returns LinkedinPostResult

    interface 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/replyToComment

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.replyToComment({});
  • repostPostReposts a post to the signed-in caller's feed, with or without their own text on top.

    Arguments

    NameTypeRequired
    input{ post: string; text?: string }Yes

    Returns LinkedinPostResult

    interface 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/repostPost

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.repostPost({});
  • saveJobSaves a job posting to the signed-in caller's saved jobs, or unsaves it.

    Arguments

    NameTypeRequired
    inputstring | { job: string; save?: boolean }Yes

    Returns { saved: boolean }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/saveJob

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.saveJob("<input>");
  • savePostSaves a post to the signed-in caller's saved items, or unsaves it.

    Arguments

    NameTypeRequired
    input{ post: string; save?: boolean }Yes

    Returns { saved: boolean }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/savePost

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = 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

    NameTypeRequired
    input{ member: string; message?: string }Yes

    Returns { sent: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/sendConnectionRequest

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.sendConnectionRequest({});
  • sendMessageSends a LinkedIn message as the signed-in caller.

    Arguments

    NameTypeRequired
    input{ conversation?: string; member?: string; text: string }Yes

    Returns { sent: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/sendMessage

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.sendMessage({});
  • setProfilePhotoReplaces the signed-in caller's profile photo with an image from a URL or uploaded file.

    Arguments

    NameTypeRequired
    input{ base64: string; mimeType: "image/jpeg" | "image/png" } | { url: string }Yes

    Returns { updated: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/setProfilePhoto

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.setProfilePhoto({});
  • subscribeToNewsletterSubscribes the signed-in caller to a LinkedIn newsletter, or unsubscribes when subscribe: false.

    Arguments

    NameTypeRequired
    inputstring | { newsletter: string; subscribe?: boolean }Yes

    Returns { subscribed: boolean }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/subscribeToNewsletter

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.subscribeToNewsletter("<input>");
  • updateProfileEdits the signed-in caller's own profile headline and About text.

    Arguments

    NameTypeRequired
    input{ headline?: string; about?: string }Yes

    Returns { updated: string[] }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/updateProfile

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.updateProfile({});
  • withdrawInvitationWithdraws a connection invitation the signed-in caller sent and is still pending, by the id listSentInvitations returned.

    Arguments

    NameTypeRequired
    invitationstringYes

    Returns { withdrawn: true }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/linkedin/withdrawInvitation

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.linkedin.withdrawInvitation("<invitation>");

Use it from code