Actions: LinkedIn

Send. One LinkedIn invitation per contact, with an optional note (at most 300 characters once filled). A contact already connected to the identity is skipped ALREADY_CONNECTED, one with an invitation pending INVITE_PENDING. Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. {{firstName}}, {{lastName}}, {{company}}, {{title}}, {{headline}}, {{industry}} are filled from the stored contact, as sequences fill them; a target missing a field is skipped MISSING_TEMPLATE_VARIABLES, one over LinkedIn's limit TOO_LONG. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's rendered content frozen; a person approves it in the app, then it runs. Right before each send the content is rendered again from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). A person this identity already sent the same kind of touch to within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED): Owlbound checks its own send log on the identity's LinkedIn accounts (sequences, plays, forms, the inbox and the API all write it, before and after each request), succeeded API actions, and for messages and InMail the person's synced LinkedIn conversations (outbound messages, including ones sent on LinkedIn itself). Invitations sent outside Owlbound are seen only through the connection state. The check runs again right before the request, once the account is free. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. Never sent twice: a send whose outcome is unknown (timeout, provider 5xx) is checked against LinkedIn (sent invitations, the chat) and otherwise fails OUTCOME_UNKNOWN for a person to check; it is never retried. 7 credits (sequence.linkedin.connect) per invitation sent; skips and failures are free.

Send. One LinkedIn message per contact (at most 8,000 characters once filled). Needs a connection with the identity (NOT_CONNECTED otherwise). Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. {{firstName}}, {{lastName}}, {{company}}, {{title}}, {{headline}}, {{industry}} are filled from the stored contact, as sequences fill them; a target missing a field is skipped MISSING_TEMPLATE_VARIABLES, one over LinkedIn's limit TOO_LONG. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's rendered content frozen; a person approves it in the app, then it runs. Right before each send the content is rendered again from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). A person this identity already sent the same kind of touch to within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED): Owlbound checks its own send log on the identity's LinkedIn accounts (sequences, plays, forms, the inbox and the API all write it, before and after each request), succeeded API actions, and for messages and InMail the person's synced LinkedIn conversations (outbound messages, including ones sent on LinkedIn itself). Invitations sent outside Owlbound are seen only through the connection state. The check runs again right before the request, once the account is free. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. Never sent twice: a send whose outcome is unknown (timeout, provider 5xx) is checked against LinkedIn (sent invitations, the chat) and otherwise fails OUTCOME_UNKNOWN for a person to check; it is never retried. 6 credits (sequence.linkedin.send) per message sent.

Send. One LinkedIn InMail per contact: subject (at most 200 characters) and message (at most 1,900) once filled. The account needs InMail (Sales Navigator, Recruiter or Premium) and credits (NO_INMAIL_CREDITS otherwise). Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. {{firstName}}, {{lastName}}, {{company}}, {{title}}, {{headline}}, {{industry}} are filled from the stored contact, as sequences fill them; a target missing a field is skipped MISSING_TEMPLATE_VARIABLES, one over LinkedIn's limit TOO_LONG. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's rendered content frozen; a person approves it in the app, then it runs. Right before each send the content is rendered again from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). A person this identity already sent the same kind of touch to within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED): Owlbound checks its own send log on the identity's LinkedIn accounts (sequences, plays, forms, the inbox and the API all write it, before and after each request), succeeded API actions, and for messages and InMail the person's synced LinkedIn conversations (outbound messages, including ones sent on LinkedIn itself). Invitations sent outside Owlbound are seen only through the connection state. The check runs again right before the request, once the account is free. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. Never sent twice: a send whose outcome is unknown (timeout, provider 5xx) is checked against LinkedIn (sent invitations, the chat) and otherwise fails OUTCOME_UNKNOWN for a person to check; it is never retried. 38 credits (sequence.inmail.send, the catalog price) per InMail sent.

Send. Opens each contact's LinkedIn profile from the identity's account: with notify (default true) the person sees "viewed your profile"; notify: false views it without the notification (still counted against the account's daily profile views). Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's content frozen; a person approves it in the app, then it runs. Right before each send the content is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). Never twice: a person this identity already gave the same touch within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED), whatever sent it (sequences, plays, the app, the API: Owlbound's send log on the identity's LinkedIn accounts, written before and after each request, and succeeded API actions), checked again right before the request. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. A send whose outcome is unknown (timeout, provider 5xx) fails OUTCOME_UNKNOWN for a person to check; it is never retried. 2 credits (sequence.linkedin.view) per profile viewed; skips and failures are free.

Send. The identity follows each contact's profile (counted against the account's 50 follows a day, shared with sequences). Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's content frozen; a person approves it in the app, then it runs. Right before each send the content is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). Never twice: a person this identity already gave the same touch within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED), whatever sent it (sequences, plays, the app, the API: Owlbound's send log on the identity's LinkedIn accounts, written before and after each request, and succeeded API actions), checked again right before the request. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. A send whose outcome is unknown (timeout, provider 5xx) fails OUTCOME_UNKNOWN for a person to check; it is never retried. 2 credits (sequence.linkedin.engage) per follow; skips and failures are free.

Send. The identity stops following each contact's profile (counted against the account's follow limit, like a follow). Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's content frozen; a person approves it in the app, then it runs. Right before each send the content is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). Never twice: a person this identity already gave the same touch within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED), whatever sent it (sequences, plays, the app, the API: Owlbound's send log on the identity's LinkedIn accounts, written before and after each request, and succeeded API actions), checked again right before the request. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. A send whose outcome is unknown (timeout, provider 5xx) fails OUTCOME_UNKNOWN for a person to check; it is never retried. 2 credits (sequence.linkedin.engage) per unfollow; skips and failures are free.

Send. Likes input.postUrl (then the request targets exactly the post's author, one contact) or, without it, each contact's latest post (none: skipped NO_POSTS). Never twice per post: a post this identity already liked within 30 days is skipped. Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's content frozen; a person approves it in the app, then it runs. Right before each send the content is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). Never twice: a person this identity already gave the same touch within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED), whatever sent it (sequences, plays, the app, the API: Owlbound's send log on the identity's LinkedIn accounts, written before and after each request, and succeeded API actions), checked again right before the request. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. A send whose outcome is unknown (timeout, provider 5xx) fails OUTCOME_UNKNOWN for a person to check; it is never retried. 2 credits (sequence.linkedin.engage) per like; skips and failures are free.

Send. Comments input.comment (a template filled from the stored contact: {{firstName}}, {{company}}, ...; at most 1,250 characters once filled) on input.postUrl (then exactly one target, the post's author) or, without it, on each contact's latest post (none: skipped NO_POSTS). Never twice per post. Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's content frozen; a person approves it in the app, then it runs. Right before each send the content is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). Never twice: a person this identity already gave the same touch within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED), whatever sent it (sequences, plays, the app, the API: Owlbound's send log on the identity's LinkedIn accounts, written before and after each request, and succeeded API actions), checked again right before the request. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. A send whose outcome is unknown (timeout, provider 5xx) fails OUTCOME_UNKNOWN for a person to check; it is never retried. 2 credits (sequence.linkedin.engage) per comment; skips and failures are free.

Send. The identity reposts input.postSocialId (the post's URN or URL), with an optional comment (template, at most 3,000 characters once filled). One target: the post's author. Never twice per post. Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's content frozen; a person approves it in the app, then it runs. Right before each send the content is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). Never twice: a person this identity already gave the same touch within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED), whatever sent it (sequences, plays, the app, the API: Owlbound's send log on the identity's LinkedIn accounts, written before and after each request, and succeeded API actions), checked again right before the request. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. A send whose outcome is unknown (timeout, provider 5xx) fails OUTCOME_UNKNOWN for a person to check; it is never retried. 2 credits (sequence.linkedin.engage) per repost (10 a day per workspace); skips and failures are free.

Send. A threaded reply input.text (template, at most 1,250 characters once filled) to comment commentId on post postExternalId. One target: the comment's author. Never twice per comment. Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's content frozen; a person approves it in the app, then it runs. Right before each send the content is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). Never twice: a person this identity already gave the same touch within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED), whatever sent it (sequences, plays, the app, the API: Owlbound's send log on the identity's LinkedIn accounts, written before and after each request, and succeeded API actions), checked again right before the request. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. A send whose outcome is unknown (timeout, provider 5xx) fails OUTCOME_UNKNOWN for a person to check; it is never retried. 2 credits (sequence.linkedin.engage) per reply; skips and failures are free.

Send. Endorses input.skillName on each contact's profile. LinkedIn lets only first-degree connections endorse: a contact not connected to the identity is skipped NOT_CONNECTED; a skill the profile does not list fails PROVIDER_REFUSED (free). Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's content frozen; a person approves it in the app, then it runs. Right before each send the content is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). Never twice: a person this identity already gave the same touch within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED), whatever sent it (sequences, plays, the app, the API: Owlbound's send log on the identity's LinkedIn accounts, written before and after each request, and succeeded API actions), checked again right before the request. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. A send whose outcome is unknown (timeout, provider 5xx) fails OUTCOME_UNKNOWN for a person to check; it is never retried. 2 credits (sequence.linkedin.engage) per endorsement (20 a day per workspace); skips and failures are free.

Send. Withdraws the identity's pending LinkedIn invitation to each contact, found in the account's sent invitations before anything is claimed (none: skipped NO_PENDING_INVITE); the contact's connection status becomes withdrawn. Withdrawing only lowers contact, so a suppressed, excluded or unsubscribed contact's invitation is still withdrawn. Counted against the account's 20 withdrawals a day. Sent from the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), to each target contact's stored LinkedIn profile. Always async and reviewed by default: the action is created pending_approval (the workspace default; the dashboard agent and MCP always) with every target's content frozen; a person approves it in the app, then it runs. Right before each send the content is rebuilt from the contact: a contact changed since the approval is skipped CONTENT_CHANGED. Every send passes the send gate: the key is re-checked (API_KEY_REVOKED); suppressed, excluded or unsubscribed contacts are skipped, and so is a contact an active sequence is working on (IN_SEQUENCE). Never twice: a person this identity already gave the same touch within 30 days is skipped (ALREADY_SENT, ALREADY_CONTACTED), whatever sent it (sequences, plays, the app, the API: Owlbound's send log on the identity's LinkedIn accounts, written before and after each request, and succeeded API actions), checked again right before the request. The account's daily limits, warm-up and health apply as for sequences; a send that must wait is scheduled (RATE_LIMITED, WARMING_UP, IDENTITY_BUSY, ...) and runs later. A send whose outcome is unknown (timeout, provider 5xx) fails OUTCOME_UNKNOWN for a person to check; it is never retried. Free.

Send. One post (input.content, at most 3,000 characters; up to 2 mediaUrls, https, fetched with the SSRF guard) on the identity's own LinkedIn feed (the key's bound identity, else identityId; a session defaults to the member's own). Target none: the action has one target, the post. Always reviewed: the action is created pending_approval whatever the key's approval mode (a public post always waits for a person); the text, media and time are frozen at approval, and a post changed since is never published (CONTENT_CHANGED). Published at most once: a request that may have gone out (timeout, provider 5xx) ends OUTCOME_UNKNOWN and is never repeated. With scheduledAt (an ISO date in the next 5 days) the post waits scheduled and goes out then, through the same checks; approved after that time, it is skipped SCHEDULE_PASSED (never published late). The media files are read when the action is created and their bytes frozen too: a file changed behind its URL is never posted (CONTENT_CHANGED); media that cannot be read (not an image, video or PDF of at most 20 MB, 25 MB for all of a post's media) is 400. Counted against the workspace's own posts (10 a day) and the key's daily sends; the account's health applies. Free.

Whether each contact is a first-degree connection of the identity (the account's relations list, cached up to 6 hours) and, when not, whether an invitation from it is pending (the account's sent invitations). Result {connected, status} with status connected, pending or not_connected. No profile is opened. Read class, free, never reviewed: nothing is sent or written and nobody is notified. Read through the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), never another workspace's. Targets: a contact with a LinkedIn URL, contacts or table rows. One target runs inline (200 {data: {action, result}}); more (or mode: "async") create an async run (202); dryRun: true returns the plan and reads nothing.

Whether each contact wrote to the identity on LinkedIn since input.since (an ISO date in the past): the synced inbox first (inbound messages of the contact's LinkedIn conversations on the identity's account), then the chat's last messages on LinkedIn when the inbox has nothing yet. Result {replied, repliedAt, source}. Read class, free, never reviewed: nothing is sent or written and nobody is notified. Read through the identity's own LinkedIn account (the key's bound identity, else identityId; a session defaults to the member's own), never another workspace's. Targets: a contact with a LinkedIn URL, contacts or table rows. One target runs inline (200 {data: {action, result}}); more (or mode: "async") create an async run (202); dryRun: true returns the plan and reads nothing.