# Create Blacklist Source: https://docs.linkedcamp.com/api-reference/blacklists/create-blacklist POST https://api.linkedcamp.com/blacklists Add a blacklist entry to prevent outreach to specific profiles, job titles, or keywords. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Body Parameters **type** `string` *required* The type of blacklist entry. Available values: `PROFILE_URL`, `JOB_TITLE`, `KEYWORD` **keyword** `string` *required* The value to blacklist. Depending on the type, this could be a LinkedIn profile URL, a job title, or a keyword. **linkedInAccountEmail** `string` The LinkedIn account email to associate the blacklist with. **Required** if the user has more than one linked LinkedIn account. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/blacklists \ -H "token: YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "type": "PROFILE_URL", "keyword": "https://www.linkedin.com/in/johndoe" }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/blacklists", headers={"token": "YOUR_API_TOKEN"}, json={ "type": "PROFILE_URL", "keyword": "https://www.linkedin.com/in/johndoe", }, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/blacklists", { method: "POST", headers: { "token": "YOUR_API_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ type: "PROFILE_URL", keyword: "https://www.linkedin.com/in/johndoe", }), }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Blacklist added successfully!" } ``` ```json 200 - Error theme={null} { "success": false, "message": "Invalid type (Possible Values: PROFILE_URL, JOB_TITLE, KEYWORD)" } ``` # List Blacklists Source: https://docs.linkedcamp.com/api-reference/blacklists/list-blacklists GET https://api.linkedcamp.com/blacklists Returns blacklist entries for the authenticated user, optionally filtered by type. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Query Parameters **type** `string` Filter blacklist entries by type. Available values: `PROFILE_URL`, `KEYWORD`, `JOB_TITLE` ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **data** `array` Array of blacklist entries. **Blacklist Properties** **keyword** `string` The blacklisted value. **type** `string` The blacklist type (PROFILE\_URL, JOB\_TITLE, or KEYWORD). **createdAt** `number` Creation timestamp. ```bash cURL theme={null} curl -X GET "https://api.linkedcamp.com/blacklists?type=PROFILE_URL" \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/blacklists", headers={"token": "YOUR_API_TOKEN"}, params={"type": "PROFILE_URL"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/blacklists?type=PROFILE_URL", { headers: { "token": "YOUR_API_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Blacklist found successfully!", "data": [ { "keyword": "https://www.linkedin.com/in/johndoe", "type": "PROFILE_URL", "createdAt": 1625000000000 } ] } ``` ```json 200 - No results theme={null} { "success": false, "message": "Records not found!" } ``` # Create Campaign Source: https://docs.linkedcamp.com/api-reference/campaigns/create-campaign POST https://api.linkedcamp.com/campaigns Create a new LinkedIn outreach campaign. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Body Parameters **title** `string` *required* The name of the campaign. **url** `string` A LinkedIn search URL to source leads from. For example, a LinkedIn People Search URL with filters applied. **sequence** `string` *required* The type of outreach sequence to use. Available values: `CONNECT`, `MESSAGE`, `INMAIL`, `EMAIL` **content** `object` *required* The message content for each step of the sequence. Fields vary based on the sequence type. **Content Properties** **longNote** `string` Connection request note (275 characters max). Used with `CONNECT` sequence. **shortNote** `string` Short connection note (175 characters max). Used with `CONNECT` sequence. **message1** `string` First follow-up message. **message2** `string` Second follow-up message. **message3** `string` Third follow-up message. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **campaignId** `string` The ID of the newly created campaign. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/campaigns \ -H "token: YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "title": "Outreach Campaign", "url": "https://www.linkedin.com/search/results/people/?network=%5B%22S%22%5D&origin=FACETED_SEARCH&sid=Z6B", "sequence": "CONNECT", "content": { "longNote": "Hi {{firstName}}, I noticed we share similar interests. Would love to connect!", "shortNote": "Hi {{firstName}}, let'\''s connect!", "message1": "Thanks for connecting! I wanted to reach out about...", "message2": "Just following up on my previous message...", "message3": "Final follow-up - would love to hear your thoughts." } }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/campaigns", headers={"token": "YOUR_API_TOKEN"}, json={ "title": "Outreach Campaign", "url": "https://www.linkedin.com/search/results/people/?network=%5B%22S%22%5D&origin=FACETED_SEARCH&sid=Z6B", "sequence": "CONNECT", "content": { "longNote": "Hi {{firstName}}, I noticed we share similar interests. Would love to connect!", "shortNote": "Hi {{firstName}}, let's connect!", "message1": "Thanks for connecting! I wanted to reach out about...", "message2": "Just following up on my previous message...", "message3": "Final follow-up - would love to hear your thoughts.", }, }, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/campaigns", { method: "POST", headers: { "token": "YOUR_API_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ title: "Outreach Campaign", url: "https://www.linkedin.com/search/results/people/?network=%5B%22S%22%5D&origin=FACETED_SEARCH&sid=Z6B", sequence: "CONNECT", content: { longNote: "Hi {{firstName}}, I noticed we share similar interests. Would love to connect!", shortNote: "Hi {{firstName}}, let's connect!", message1: "Thanks for connecting! I wanted to reach out about...", message2: "Just following up on my previous message...", message3: "Final follow-up - would love to hear your thoughts.", }, }), }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Campaign created successfully!", "campaignId": "60f7a1b2c3d4e5f6a7b8c9d0" } ``` ```json 400 theme={null} { "success": false, "message": "Title is required!" } ``` # Get Campaign Source: https://docs.linkedcamp.com/api-reference/campaigns/get-campaign GET https://api.linkedcamp.com/campaigns/{campaignId} Returns detailed data for a specific campaign. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Path Parameters **campaignId** `string` *required* The ID of the campaign. You can get this from the campaign URL or from the [List Campaigns](/api-reference/campaigns/list-campaigns) endpoint. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **data** `object` The campaign details. **Campaign Properties** **\_id** `string` Campaign ID. **title** `string` Campaign name. **keywords** `array` Search keywords associated with the campaign. **url** `string` LinkedIn search URL. **status** `string` Current campaign status. **total** `number` Total number of leads. **stats** `object` Campaign statistics and metrics. ```bash cURL theme={null} curl -X GET https://api.linkedcamp.com/campaigns/60f7a1b2c3d4e5f6a7b8c9d0 \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/campaigns/60f7a1b2c3d4e5f6a7b8c9d0", headers={"token": "YOUR_API_TOKEN"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/campaigns/60f7a1b2c3d4e5f6a7b8c9d0", { headers: { "token": "YOUR_API_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Campaign found successfully!", "data": { "_id": "60f7a1b2c3d4e5f6a7b8c9d0", "title": "Outreach Campaign", "url": "https://www.linkedin.com/search/results/people/...", "status": "ACTIVE", "total": 150, "stats": {} } } ``` ```json 200 - Not found theme={null} { "success": false, "message": "Campaign not found!" } ``` # Get Campaign Stats Source: https://docs.linkedcamp.com/api-reference/campaigns/get-campaign-stats GET https://api.linkedcamp.com/campaigns/{campaignId}/stats Returns analytics and statistics for a specific campaign, with optional date range filtering. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Path Parameters **campaignId** `string` *required* The ID of the campaign. ## Query Parameters **userId** `string` Optional user ID to filter stats by a specific user. **range** `string` Optional JSON string specifying a date range for filtering stats. Format: `{"from": "YYYY-MM-DD", "to": "YYYY-MM-DD"}` Example: `range={"from": "2024-01-01", "to": "2024-01-31"}` ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **campaignId** `string` The campaign ID. ```bash cURL theme={null} curl -X GET 'https://api.linkedcamp.com/campaigns/60f7a1b2c3d4e5f6a7b8c9d0/stats?range={"from":"2024-01-01","to":"2024-01-31"}' \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import json import requests response = requests.get( "https://api.linkedcamp.com/campaigns/60f7a1b2c3d4e5f6a7b8c9d0/stats", headers={"token": "YOUR_API_TOKEN"}, params={"range": json.dumps({"from": "2024-01-01", "to": "2024-01-31"})}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const range = JSON.stringify({ from: "2024-01-01", to: "2024-01-31" }); const url = `https://api.linkedcamp.com/campaigns/60f7a1b2c3d4e5f6a7b8c9d0/stats?range=${encodeURIComponent(range)}`; const response = await fetch(url, { headers: { "token": "YOUR_API_TOKEN" }, }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Campaign stats found successfully!", "campaignId": "60f7a1b2c3d4e5f6a7b8c9d0" } ``` ```json 400 theme={null} { "success": false, "message": "Invalid range format. Must be JSON: {\"from\": \"YYYY-MM-DD\", \"to\": \"YYYY-MM-DD\"}" } ``` # List Campaigns Source: https://docs.linkedcamp.com/api-reference/campaigns/list-campaigns GET https://api.linkedcamp.com/campaigns Returns all campaigns for the authenticated user, optionally filtered by status. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Query Parameters **status** `string` Filter campaigns by status. You can pass multiple statuses separated by commas. Available values: `PENDING`, `ACTIVE`, `PAUSED`, `DRAFTED`, `COMPLETED`, `FAILED`, `ARCHIVED` Example: `status=ACTIVE` or `status=ACTIVE,PAUSED` ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **total** `number` Total number of campaigns returned. **data** `array` Array of campaign objects. **Campaign Properties** **\_id** `string` Campaign ID. **title** `string` Campaign name. **url** `string` LinkedIn search URL associated with the campaign. **status** `string` Current campaign status. **total** `number` Total number of leads in the campaign. ```bash cURL theme={null} curl -X GET "https://api.linkedcamp.com/campaigns?status=ACTIVE" \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/campaigns", headers={"token": "YOUR_API_TOKEN"}, params={"status": "ACTIVE"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/campaigns?status=ACTIVE", { headers: { "token": "YOUR_API_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "ACTIVE campaigns found successfully!", "total": 2, "data": [ { "_id": "60f7a1b2c3d4e5f6a7b8c9d0", "title": "Outreach Campaign", "url": "https://www.linkedin.com/search/results/people/...", "status": "ACTIVE", "total": 150 } ] } ``` ```json 200 - No results theme={null} { "success": false, "message": "Compaigns not found!" } ``` # Update Campaign Status Source: https://docs.linkedcamp.com/api-reference/campaigns/update-campaign-status PUT https://api.linkedcamp.com/campaigns/{campaignId} Update the status of a specific campaign. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Path Parameters **campaignId** `string` *required* The ID of the campaign to update. ## Query Parameters **status** `string` *required* The new status to set for the campaign. Available values: `ACTIVE`, `PAUSED`, `COMPLETED`, `FAILED`, `ARCHIVED` ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X PUT "https://api.linkedcamp.com/campaigns/60f7a1b2c3d4e5f6a7b8c9d0?status=PAUSED" \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.put( "https://api.linkedcamp.com/campaigns/60f7a1b2c3d4e5f6a7b8c9d0", headers={"token": "YOUR_API_TOKEN"}, params={"status": "PAUSED"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/campaigns/60f7a1b2c3d4e5f6a7b8c9d0?status=PAUSED", { method: "PUT", headers: { "token": "YOUR_API_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Campaign PAUSED successfully!" } ``` ```json 400 theme={null} { "success": false, "message": "Campaign id is required!" } ``` # Get Messages Source: https://docs.linkedcamp.com/api-reference/conversations/get-messages GET https://api.linkedcamp.com/conversations/{conversationId} Returns all messages in a specific conversation. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Path Parameters **conversationId** `string` *required* The conversation ID. You can obtain this from the lead data via the [List Leads](/api-reference/leads/list-leads) or [Get Lead](/api-reference/leads/get-lead) endpoints. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X GET https://api.linkedcamp.com/conversations/60f7a1b2c3d4e5f6a7b8c9d1 \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/conversations/60f7a1b2c3d4e5f6a7b8c9d1", headers={"token": "YOUR_API_TOKEN"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/conversations/60f7a1b2c3d4e5f6a7b8c9d1", { headers: { "token": "YOUR_API_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Messages found successfully!" } ``` ```json 400 theme={null} { "success": false, "message": "Conversation id is required!" } ``` # Send Message Source: https://docs.linkedcamp.com/api-reference/conversations/send-message POST https://api.linkedcamp.com/conversations/send-message Send a message to a prospect in an existing conversation. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Body Parameters **conversationId** `string` *required* The conversation ID. You can obtain this from the lead data via the [List Leads](/api-reference/leads/list-leads) or [Get Lead](/api-reference/leads/get-lead) endpoints. **content** `string` *required* The message content to send. Control characters are automatically sanitized. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/conversations/send-message \ -H "token: YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "conversationId": "60f7a1b2c3d4e5f6a7b8c9d1", "content": "Hi John, thanks for connecting! I wanted to reach out about..." }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/conversations/send-message", headers={"token": "YOUR_API_TOKEN"}, json={ "conversationId": "60f7a1b2c3d4e5f6a7b8c9d1", "content": "Hi John, thanks for connecting! I wanted to reach out about...", }, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/conversations/send-message", { method: "POST", headers: { "token": "YOUR_API_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ conversationId: "60f7a1b2c3d4e5f6a7b8c9d1", content: "Hi John, thanks for connecting! I wanted to reach out about...", }), } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Message sent successfully!" } ``` ```json 401 theme={null} { "success": false, "message": "Conversation Id is required!" } ``` # Add Leads to Campaign Source: https://docs.linkedcamp.com/api-reference/leads/add-leads-to-campaign POST https://api.linkedcamp.com/leads/add-to-campaign Add one or more leads to an existing campaign. Leads are automatically deduplicated within the same campaign. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Body Parameters **campaignId** `string` *required* The ID of the campaign to add leads to. The campaign must not be in `DELETED` or `FAILED` status. **leads** `array` *required* Array of lead objects to add. **Lead Object Properties** **profileLink** `string` *required* LinkedIn profile URL of the lead. Supports standard LinkedIn URLs, Sales Navigator URLs, and Recruiter URLs. **firstName** `string` Lead's first name. **lastName** `string` Lead's last name. **fullName** `string` Lead's full name. If not provided but firstName and lastName are, it will be auto-generated. > [!NOTE] > > * Leads that already exist in the campaign (matched by `profileLink`) will be skipped. > * Sales Navigator and Recruiter URLs are automatically converted to standard LinkedIn URLs. > * You can pass additional custom fields on each lead object. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/leads/add-to-campaign \ -H "token: YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "campaignId": "60f7a1b2c3d4e5f6a7b8c9d0", "leads": [ { "profileLink": "https://www.linkedin.com/in/johndoe", "firstName": "John", "lastName": "Doe" }, { "profileLink": "https://www.linkedin.com/in/janesmith", "firstName": "Jane", "lastName": "Smith" } ] }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/leads/add-to-campaign", headers={"token": "YOUR_API_TOKEN"}, json={ "campaignId": "60f7a1b2c3d4e5f6a7b8c9d0", "leads": [ { "profileLink": "https://www.linkedin.com/in/johndoe", "firstName": "John", "lastName": "Doe", }, { "profileLink": "https://www.linkedin.com/in/janesmith", "firstName": "Jane", "lastName": "Smith", }, ], }, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/leads/add-to-campaign", { method: "POST", headers: { "token": "YOUR_API_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ campaignId: "60f7a1b2c3d4e5f6a7b8c9d0", leads: [ { profileLink: "https://www.linkedin.com/in/johndoe", firstName: "John", lastName: "Doe", }, { profileLink: "https://www.linkedin.com/in/janesmith", firstName: "Jane", lastName: "Smith", }, ], }), } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Leads added successfully" } ``` ```json 400 theme={null} { "success": false, "message": "Failed to add leads into this campaign!" } ``` # Get Lead Source: https://docs.linkedcamp.com/api-reference/leads/get-lead GET https://api.linkedcamp.com/leads/{leadId} Returns detailed data for a specific lead including company information and conversations. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Path Parameters **leadId** `string` *required* The ID of the lead. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **data** `object` **Data Properties** **lead** `object` The lead details (same fields as in [List Leads](/api-reference/leads/list-leads)). **company** `object` The lead's associated company data (if available). ```bash cURL theme={null} curl -X GET https://api.linkedcamp.com/leads/60f7a1b2c3d4e5f6a7b8c9d0 \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/leads/60f7a1b2c3d4e5f6a7b8c9d0", headers={"token": "YOUR_API_TOKEN"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/leads/60f7a1b2c3d4e5f6a7b8c9d0", { headers: { "token": "YOUR_API_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Lead found successfully!", "data": { "lead": { "profileLink": "https://www.linkedin.com/in/johndoe", "fullName": "John Doe", "firstName": "John", "lastName": "Doe", "status": "CONNECTED", "headline": "CEO at Acme Corp", "conversations": [ { "type": "LINKEDIN", "conversationId": "60f7a1b2c3d4e5f6a7b8c9d1" } ] }, "company": { "name": "Acme Corp", "industry": "Technology" } } } ``` ```json 200 - Not found theme={null} { "success": false, "message": "Lead not found!", "data": { "lead": null, "company": null } } ``` # List Leads Source: https://docs.linkedcamp.com/api-reference/leads/list-leads GET https://api.linkedcamp.com/leads Returns leads for a specific campaign, optionally filtered by status. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Query Parameters **campaignId** `string` *required* The campaign ID to retrieve leads for. **status** `string` Filter leads by status. Available values: `FOUND`, `VIEWED`, `CONNECT_SENT`, `CONNECTED`, `REPLIED`, `MESSAGE_SENT`, `INMAILS`, `INMAIL_SENT`, `INMAIL_CREDIT`, `WITHDRAWN` ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **total** `number` Total number of leads returned. **data** `array` Array of lead objects. **Lead Properties** **profileLink** `string` LinkedIn profile URL. **salesNavLink** `string` Sales Navigator profile URL. **recruiterLink** `string` Recruiter profile URL. **fullName** `string` Lead's full name. **firstName** `string` Lead's first name. **lastName** `string` Lead's last name. **isPremium** `boolean` Whether the lead has a LinkedIn Premium account. **connectionLevel** `string` LinkedIn connection level (1st, 2nd, 3rd). **status** `string` Current lead status in the campaign. **headline** `string` LinkedIn headline. **designation** `string` Job title/designation. **location** `string` Lead's location. **bio** `string` LinkedIn bio/about section. **contact** `object` Contact information. **profileUrn** `string` LinkedIn profile URN. **conversationId** `string` Associated conversation ID. **conversations** `array` List of associated conversations with type and ID. **campaignId** `string` Campaign this lead belongs to. **companyId** `string` Associated company ID. ```bash cURL theme={null} curl -X GET "https://api.linkedcamp.com/leads?campaignId=60f7a1b2c3d4e5f6a7b8c9d0&status=CONNECTED" \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/leads", headers={"token": "YOUR_API_TOKEN"}, params={ "campaignId": "60f7a1b2c3d4e5f6a7b8c9d0", "status": "CONNECTED", }, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/leads?campaignId=60f7a1b2c3d4e5f6a7b8c9d0&status=CONNECTED", { headers: { "token": "YOUR_API_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Leads found successfully!", "total": 25, "data": [ { "profileLink": "https://www.linkedin.com/in/johndoe", "fullName": "John Doe", "firstName": "John", "lastName": "Doe", "status": "CONNECTED", "headline": "CEO at Acme Corp", "location": "San Francisco, CA", "conversations": [ { "type": "LINKEDIN", "conversationId": "60f7a1b2c3d4e5f6a7b8c9d1", "url": "https://www.linkedin.com/messaging/thread/..." } ] } ] } ``` # Update Lead Source: https://docs.linkedcamp.com/api-reference/leads/update-lead POST https://api.linkedcamp.com/leads/update Update information for a specific lead across all campaigns it appears in. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Body Parameters **profileLink** `string` *required* The LinkedIn profile URL of the lead to update. Must be a valid `linkedin.com` URL. **firstName** `string` Updated first name. **lastName** `string` Updated last name. **email** `string` Updated email address. **emailStatus** `string` Email verification status. Defaults to `unknown` if an email is provided without a status. > [!NOTE] > > Any additional fields passed in the request body will be stored as custom fields on the lead and campaign. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/leads/update \ -H "token: YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "profileLink": "https://www.linkedin.com/in/johndoe", "firstName": "John", "lastName": "Doe", "email": "john@acme.com", "emailStatus": "valid", "company": "Acme Corp", "phone": "+1234567890" }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/leads/update", headers={"token": "YOUR_API_TOKEN"}, json={ "profileLink": "https://www.linkedin.com/in/johndoe", "firstName": "John", "lastName": "Doe", "email": "john@acme.com", "emailStatus": "valid", "company": "Acme Corp", "phone": "+1234567890", }, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/leads/update", { method: "POST", headers: { "token": "YOUR_API_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ profileLink: "https://www.linkedin.com/in/johndoe", firstName: "John", lastName: "Doe", email: "john@acme.com", emailStatus: "valid", company: "Acme Corp", phone: "+1234567890", }), }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Lead updated successfully!" } ``` ```json 200 - Error theme={null} { "success": false, "message": "Lead doesn't exists in this user campaigns!" } ``` # Update Lead Status Source: https://docs.linkedcamp.com/api-reference/leads/update-lead-status PUT https://api.linkedcamp.com/leads/{leadId} Pause, resume, or delete a lead in a campaign. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Path Parameters **leadId** `string` *required* The ID of the lead. ## Query Parameters **status** `string` *required* The action to perform on the lead. Available values: * `PAUSE` - Pause outreach to this lead * `RESUME` - Resume outreach to this lead * `DELETED` - Soft-delete the lead from the campaign ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X PUT "https://api.linkedcamp.com/leads/60f7a1b2c3d4e5f6a7b8c9d0?status=PAUSE" \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.put( "https://api.linkedcamp.com/leads/60f7a1b2c3d4e5f6a7b8c9d0", headers={"token": "YOUR_API_TOKEN"}, params={"status": "PAUSE"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/leads/60f7a1b2c3d4e5f6a7b8c9d0?status=PAUSE", { method: "PUT", headers: { "token": "YOUR_API_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Lead PAUSE successfully" } ``` ```json 200 - Error theme={null} { "success": false, "message": "Lead id is required!" } ``` # API Reference Overview Source: https://docs.linkedcamp.com/api-reference/overview Complete reference for all LinkedCamp API endpoints ## Base URL ``` https://api.linkedcamp.com ``` ## Available Endpoints ### Users | Method | Endpoint | Description | | - | - | - | | GET | `/users/me` | Get current authenticated user | | GET | `/users/{userId}` | Generate token for a user | | POST | `/users/register` | Register a new sub-account | | POST | `/users/pause` | Pause a sub-account | | POST | `/users/resume` | Resume a sub-account | | POST | `/users/cancel` | Cancel (delete) a sub-account | ### Campaigns | Method | Endpoint | Description | | - | - | - | | POST | `/campaigns` | Create a new campaign | | GET | `/campaigns` | List all campaigns | | GET | `/campaigns/{campaignId}` | Get a specific campaign | | GET | `/campaigns/{campaignId}/stats` | Get campaign statistics | | PUT | `/campaigns/{campaignId}` | Update campaign status | ### Leads | Method | Endpoint | Description | | - | - | - | | GET | `/leads` | List leads for a campaign | | GET | `/leads/{leadId}` | Get a specific lead | | POST | `/leads/update` | Update lead information | | PUT | `/leads/{leadId}` | Pause, resume, or delete a lead | | POST | `/leads/add-to-campaign` | Add leads to an existing campaign | ### Conversations | Method | Endpoint | Description | | - | - | - | | POST | `/conversations/send-message` | Send a message to a lead | | GET | `/conversations/{conversationId}` | Get conversation messages | ### Webhooks | Method | Endpoint | Description | | - | - | - | | POST | `/webhooks` | Create a webhook | | GET | `/webhooks` | List all webhooks | | GET | `/webhooks/{webhookId}` | Get a specific webhook | | DELETE | `/webhooks/{webhookId}` | Delete a webhook | ### Tags | Method | Endpoint | Description | | - | - | - | | POST | `/tags` | Create a tag | | GET | `/tags` | List all tags | ### Blacklists | Method | Endpoint | Description | | - | - | - | | POST | `/blacklists` | Add a blacklist entry | | GET | `/blacklists` | List blacklist entries | ### API Tokens | Method | Endpoint | Description | | - | - | - | | GET | `/tokens` | Get API token for a sub-account (agency) | # Create Tag Source: https://docs.linkedcamp.com/api-reference/tags/create-tag POST https://api.linkedcamp.com/tags Create a new tag for organizing and categorizing leads. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Body Parameters **name** `string` *required* The tag name. **color** `string` *required* The tag color (hex color code). ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/tags \ -H "token: YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "Hot Lead", "color": "#FF5733" }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/tags", headers={"token": "YOUR_API_TOKEN"}, json={ "name": "Hot Lead", "color": "#FF5733", }, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/tags", { method: "POST", headers: { "token": "YOUR_API_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ name: "Hot Lead", color: "#FF5733", }), }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Tag added successfully!" } ``` ```json 200 - Error theme={null} { "success": false, "message": "Name is required!" } ``` # List Tags Source: https://docs.linkedcamp.com/api-reference/tags/list-tags GET https://api.linkedcamp.com/tags Returns all tags created by the authenticated user. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **data** `array` Array of tag objects. **Tag Properties** **content** `string` Tag name. **color** `string` Tag color (hex code). **createdAt** `number` Creation timestamp. **updatedAt** `number` Last update timestamp. ```bash cURL theme={null} curl -X GET https://api.linkedcamp.com/tags \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/tags", headers={"token": "YOUR_API_TOKEN"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/tags", { headers: { "token": "YOUR_API_TOKEN" }, }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Tags found successfully!", "data": [ { "content": "Hot Lead", "color": "#FF5733", "createdAt": 1625000000000, "updatedAt": 1625000000000 } ] } ``` ```json 200 - No results theme={null} { "success": false, "message": "Tags not found!" } ``` # Get API Token Source: https://docs.linkedcamp.com/api-reference/tokens/get-api-token GET https://api.linkedcamp.com/tokens Retrieve the API token for a specific sub-account. This endpoint is only available to agency owners. > [!NOTE] > > This endpoint requires an **agency owner** token. ## Headers **token** `string` *required* Token from the agency owner account. ## Query Parameters **accountEmail** `string` *required* The email address of the sub-account to retrieve the API token for. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **token** `string` The API token for the specified sub-account. ```bash cURL theme={null} curl -X GET "https://api.linkedcamp.com/tokens?accountEmail=user@example.com" \ -H "token: YOUR_AGENCY_OWNER_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/tokens", headers={"token": "YOUR_AGENCY_OWNER_TOKEN"}, params={"accountEmail": "user@example.com"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/tokens?accountEmail=user@example.com", { headers: { "token": "YOUR_AGENCY_OWNER_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Api token found successfully!", "token": "abc123..." } ``` ```json 400 theme={null} { "success": false, "message": "Invalid agency owner token." } ``` # Cancel Sub-Account Source: https://docs.linkedcamp.com/api-reference/users/cancel-subaccount POST https://api.linkedcamp.com/users/cancel Cancel and delete a sub-account from an agency account. > [!NOTE] > > This endpoint requires an **agency owner** token. This action is **irreversible**. ## Headers **token** `string` *required* Token from the agency owner account. ## Body Parameters **email** `string` *required* Email address of the sub-account to cancel. **reason** `string` *required* Reason for cancelling the sub-account. **description** `string` *required* Detailed description of why the sub-account is being cancelled. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/users/cancel \ -H "token: YOUR_AGENCY_OWNER_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "email": "jane@example.com", "reason": "Client requested cancellation", "description": "The client no longer needs LinkedIn outreach services." }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/users/cancel", headers={"token": "YOUR_AGENCY_OWNER_TOKEN"}, json={ "email": "jane@example.com", "reason": "Client requested cancellation", "description": "The client no longer needs LinkedIn outreach services.", }, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/users/cancel", { method: "POST", headers: { "token": "YOUR_AGENCY_OWNER_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ email: "jane@example.com", reason: "Client requested cancellation", description: "The client no longer needs LinkedIn outreach services.", }), }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "User deleted successfully!" } ``` ```json 401 theme={null} { "success": false, "message": "Invalid user email!" } ``` # Get Current User Source: https://docs.linkedcamp.com/api-reference/users/get-current-user GET https://api.linkedcamp.com/users/me Returns the currently authenticated user along with their linked LinkedIn and email accounts. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **user** `object` The user account details. **User Properties** **email** `string` User's email address. **fullName** `string` User's full name. **apiKey** `string` User's API key. **linkedAccount** `object` The linked LinkedIn account details. **Linked Account Properties** **fullName** `string` LinkedIn account full name. **email** `string` LinkedIn account email. **isValid** `boolean` Whether the LinkedIn account is valid. **headline** `string` LinkedIn headline. **profileLink** `string` LinkedIn profile URL. **salesNavLink** `string` Sales Navigator profile URL. **recruiterLink** `string` Recruiter profile URL. **profileUrn** `string` LinkedIn profile URN. **profilePic** `string` Profile picture URL. **invalidReason** `string` Reason if the account is invalid. **isPaused** `boolean` Whether the account is paused. **emailAccounts** `array` List of connected email accounts. **Email Account Properties** **fullName** `string` Email account display name. **email** `string` Email address. **isValid** `boolean` Whether the email account is valid. **isPaused** `boolean` Whether the email account is paused. **type** `string` Email account type. ```bash cURL theme={null} curl -X GET https://api.linkedcamp.com/users/me \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/users/me", headers={"token": "YOUR_API_TOKEN"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/users/me", { headers: { "token": "YOUR_API_TOKEN" }, }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "User found successfully!", "user": { "email": "user@example.com", "fullName": "John Doe", "apiKey": "abc123..." }, "linkedAccount": { "fullName": "John Doe", "email": "john@linkedin.com", "isValid": true, "headline": "CEO at Acme Corp", "profileLink": "https://www.linkedin.com/in/johndoe", "isPaused": false }, "emailAccounts": [ { "fullName": "John Doe", "email": "john@acme.com", "isValid": true, "isPaused": false, "type": "GMAIL" } ] } ``` # Generate Token Source: https://docs.linkedcamp.com/api-reference/users/get-token GET https://api.linkedcamp.com/users/{userId} Generates an authentication token for a specific user by their user ID. > [!NOTE] > > This endpoint does **not** require the `token` header. It generates a token using the user ID directly. ## Path Parameters **userId** `string` *required* The user ID to generate a token for. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **token** `string` The generated authentication token. ```bash cURL theme={null} curl -X GET https://api.linkedcamp.com/users/60f7a1b2c3d4e5f6a7b8c9d0 ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/users/60f7a1b2c3d4e5f6a7b8c9d0" ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/users/60f7a1b2c3d4e5f6a7b8c9d0" ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Token generated successfully!", "token": "U2FsdGVkX1..." } ``` # Pause Sub-Account Source: https://docs.linkedcamp.com/api-reference/users/pause-subaccount POST https://api.linkedcamp.com/users/pause Pause a sub-account under an agency account. > [!NOTE] > > This endpoint requires an **agency owner** token. ## Headers **token** `string` *required* Token from the agency owner account. ## Body Parameters **email** `string` *required* Email address of the sub-account to pause. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/users/pause \ -H "token: YOUR_AGENCY_OWNER_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "email": "jane@example.com" }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/users/pause", headers={"token": "YOUR_AGENCY_OWNER_TOKEN"}, json={"email": "jane@example.com"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/users/pause", { method: "POST", headers: { "token": "YOUR_AGENCY_OWNER_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ email: "jane@example.com" }), }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Sub-account paused successfully!" } ``` ```json 401 theme={null} { "success": false, "message": "Invalid user email!" } ``` # Register Sub-Account Source: https://docs.linkedcamp.com/api-reference/users/register-subaccount POST https://api.linkedcamp.com/users/register Create a new sub-account under an agency account. > [!NOTE] > > This endpoint requires an **agency owner** token. ## Headers **token** `string` *required* Token from the agency owner account. ## Body Parameters **name** `string` *required* Full name of the new sub-account user. **email** `string` *required* Email address for the new sub-account. Must be unique and not already registered. **planId** `string` The plan ID to assign to the sub-account. If not provided, defaults to "CUSTOMER". ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/users/register \ -H "token: YOUR_AGENCY_OWNER_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "Jane Smith", "email": "jane@example.com", "planId": "60f7a1b2c3d4e5f6a7b8c9d0" }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/users/register", headers={"token": "YOUR_AGENCY_OWNER_TOKEN"}, json={ "name": "Jane Smith", "email": "jane@example.com", "planId": "60f7a1b2c3d4e5f6a7b8c9d0", }, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/users/register", { method: "POST", headers: { "token": "YOUR_AGENCY_OWNER_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ name: "Jane Smith", email: "jane@example.com", planId: "60f7a1b2c3d4e5f6a7b8c9d0", }), }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Sub-account added successfully!" } ``` ```json 401 theme={null} { "success": false, "message": "User is already registered with this email!" } ``` # Resume Sub-Account Source: https://docs.linkedcamp.com/api-reference/users/resume-subaccount POST https://api.linkedcamp.com/users/resume Resume a previously paused sub-account under an agency account. > [!NOTE] > > This endpoint requires an **agency owner** token. ## Headers **token** `string` *required* Token from the agency owner account. ## Body Parameters **email** `string` *required* Email address of the sub-account to resume. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/users/resume \ -H "token: YOUR_AGENCY_OWNER_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "email": "jane@example.com" }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/users/resume", headers={"token": "YOUR_AGENCY_OWNER_TOKEN"}, json={"email": "jane@example.com"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/users/resume", { method: "POST", headers: { "token": "YOUR_AGENCY_OWNER_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ email: "jane@example.com" }), }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Sub-account resumed successfully!" } ``` ```json 401 theme={null} { "success": false, "message": "Invalid user email!" } ``` # Create Webhook Source: https://docs.linkedcamp.com/api-reference/webhooks/create-webhook POST https://api.linkedcamp.com/webhooks Create a webhook to receive real-time notifications when specific campaign events occur. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Body Parameters **title** `string` *required* A descriptive name for the webhook. **callbackUrl** `string` *required* The URL that will receive webhook POST requests when the event occurs. **event** `string` *required* The event type that triggers the webhook. Available values: | Event | Description | | - | - | | `CONNECT_INVITED` | A connection request was sent | | `ACCEPTS_REQUEST` | A connection request was accepted | | `REPLY_DETECTED` | A reply was received from a prospect | | `EMAIL_SENT` | An email was sent | | `OPENED` | An email was opened | | `BOUNCED` | An email bounced | | `CLICKED` | A link in an email was clicked | | `UNSUBSCRIBED` | A prospect unsubscribed | ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X POST https://api.linkedcamp.com/webhooks \ -H "token: YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "title": "New Connection Webhook", "callbackUrl": "https://your-server.com/webhook/linkedcamp", "event": "ACCEPTS_REQUEST" }' ``` ```python Python theme={null} import requests response = requests.post( "https://api.linkedcamp.com/webhooks", headers={"token": "YOUR_API_TOKEN"}, json={ "title": "New Connection Webhook", "callbackUrl": "https://your-server.com/webhook/linkedcamp", "event": "ACCEPTS_REQUEST", }, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/webhooks", { method: "POST", headers: { "token": "YOUR_API_TOKEN", "Content-Type": "application/json", }, body: JSON.stringify({ title: "New Connection Webhook", callbackUrl: "https://your-server.com/webhook/linkedcamp", event: "ACCEPTS_REQUEST", }), }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Webhook added successfully!" } ``` ```json 400 theme={null} { "success": false, "message": "Invalid event!" } ``` # Delete Webhook Source: https://docs.linkedcamp.com/api-reference/webhooks/delete-webhook DELETE https://api.linkedcamp.com/webhooks/{webhookId} Permanently delete a specific webhook. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Path Parameters **webhookId** `string` *required* The ID of the webhook to delete. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. ```bash cURL theme={null} curl -X DELETE https://api.linkedcamp.com/webhooks/60f7a1b2c3d4e5f6a7b8c9d0 \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.delete( "https://api.linkedcamp.com/webhooks/60f7a1b2c3d4e5f6a7b8c9d0", headers={"token": "YOUR_API_TOKEN"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/webhooks/60f7a1b2c3d4e5f6a7b8c9d0", { method: "DELETE", headers: { "token": "YOUR_API_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Webhook deleted successfully!" } ``` ```json 200 - Error theme={null} { "success": false, "message": "Invalid webhook ID!" } ``` # Get Webhook Source: https://docs.linkedcamp.com/api-reference/webhooks/get-webhook GET https://api.linkedcamp.com/webhooks/{webhookId} Returns data for a specific webhook. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Path Parameters **webhookId** `string` *required* The ID of the webhook. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **data** `object` The webhook details. **Webhook Properties** **\_id** `string` Webhook ID. **callbackUrl** `string` The callback URL. **title** `string` Webhook name. **events** `array` List of events this webhook listens to. **isValid** `boolean` Whether the webhook is active and valid. ```bash cURL theme={null} curl -X GET https://api.linkedcamp.com/webhooks/60f7a1b2c3d4e5f6a7b8c9d0 \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/webhooks/60f7a1b2c3d4e5f6a7b8c9d0", headers={"token": "YOUR_API_TOKEN"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch( "https://api.linkedcamp.com/webhooks/60f7a1b2c3d4e5f6a7b8c9d0", { headers: { "token": "YOUR_API_TOKEN" }, } ); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Webhook found successfully!", "data": { "_id": "60f7a1b2c3d4e5f6a7b8c9d0", "callbackUrl": "https://your-server.com/webhook/linkedcamp", "title": "New Connection Webhook", "events": ["ACCEPTS_REQUEST"], "isValid": true } } ``` ```json 200 - Not found theme={null} { "success": false, "message": "Webhook not found!" } ``` # List Webhooks Source: https://docs.linkedcamp.com/api-reference/webhooks/list-webhooks GET https://api.linkedcamp.com/webhooks Returns all webhooks for the authenticated user. ## Headers **token** `string` *required* Your LinkedCamp API token. ## Response **success** `boolean` Whether the request was successful. **message** `string` A human-readable result message. **data** `array` Array of webhook objects. **Webhook Properties** **\_id** `string` Webhook ID. **callbackUrl** `string` The callback URL. **title** `string` Webhook name. **events** `array` List of events this webhook listens to. **isValid** `boolean` Whether the webhook is active and valid. ```bash cURL theme={null} curl -X GET https://api.linkedcamp.com/webhooks \ -H "token: YOUR_API_TOKEN" ``` ```python Python theme={null} import requests response = requests.get( "https://api.linkedcamp.com/webhooks", headers={"token": "YOUR_API_TOKEN"}, ) print(response.json()) ``` ```javascript JavaScript theme={null} const response = await fetch("https://api.linkedcamp.com/webhooks", { headers: { "token": "YOUR_API_TOKEN" }, }); const data = await response.json(); console.log(data); ``` ```json 200 theme={null} { "success": true, "message": "Webhooks found successfully!", "data": [ { "_id": "60f7a1b2c3d4e5f6a7b8c9d0", "callbackUrl": "https://your-server.com/webhook/linkedcamp", "title": "New Connection Webhook", "events": ["ACCEPTS_REQUEST"], "isValid": true } ] } ``` # Authentication Source: https://docs.linkedcamp.com/authentication Learn how to authenticate with the LinkedCamp API ## API Token Authentication The LinkedCamp API uses token-based authentication. Every authenticated request must include a `token` header containing your API key. ```bash theme={null} curl -X GET https://api.linkedcamp.com/users/me \ -H "token: YOUR_API_TOKEN" ``` ## Obtaining Your API Token There are two ways to get your API token: ### From the Dashboard 1. Log in to your [LinkedCamp account](https://app.linkedcamp.com) 2. Navigate to **Settings** > **API** 3. Copy your API token ### Via the API (Agency Owners) Agency owners can retrieve API tokens for their sub-accounts using the [Get API Token](/api-reference/tokens/get-api-token) endpoint: ```bash theme={null} curl -X GET "https://api.linkedcamp.com/tokens?accountEmail=user@example.com" \ -H "token: AGENCY_OWNER_TOKEN" ``` ## Request Headers All API requests require the following headers: | Header | Required | Description | | - | - | - | | `token` | Yes | Your LinkedCamp API token | | `Content-Type` | Yes\* | `application/json` (for POST/PUT requests) | > [!NOTE] > > The `Content-Type` header is only required for requests that include a JSON body (POST and PUT methods). ## Authentication Errors If authentication fails, the API returns: ```json theme={null} { "success": false, "message": "Invalid Token!" } ``` Common reasons for authentication failures: | Error Message | Cause | | - | - | | `Token is required!` | The `token` header is missing from the request | | `Invalid Token!` | The token is incorrect, expired, or the account is inactive | | `User not found!` | No active user account is associated with the token | ## Token Requirements * The token must belong to an **active** user account * The user must have a **current plan** assigned * Tokens are validated on every request and the `lastUsedAt` timestamp is updated automatically # Introduction Source: https://docs.linkedcamp.com/introduction Welcome to the LinkedCamp API documentation ## Overview The LinkedCamp API allows you to programmatically manage your LinkedIn outreach campaigns, leads, conversations, webhooks, and more. Use this API to integrate LinkedCamp into your existing workflows, CRMs, and automation tools. ## Base URL All API requests should be made to: ``` https://api.linkedcamp.com ``` ## Key Features > [card] [Campaigns](/api-reference/campaigns/create-campaign) > > Create, manage, and track LinkedIn outreach campaigns programmatically. > [card] [Leads](/api-reference/leads/list-leads) > > Add leads to campaigns, update lead data, and track lead statuses. > [card] [Conversations](/api-reference/conversations/send-message) > > Send messages to prospects and retrieve conversation histories. > [card] [Webhooks](/api-reference/webhooks/create-webhook) > > Set up real-time notifications for campaign events like connection accepts or replies. ## Quick Start **1. Get your API Token** Log in to your LinkedCamp account and retrieve your API token from the settings page. Alternatively, agency owners can use the [Get API Token](/api-reference/tokens/get-api-token) endpoint. **2. Authenticate your requests** Include your API token in the `token` header of every request. ```bash theme={null} curl -H "token: YOUR_API_TOKEN" https://api.linkedcamp.com/users/me ``` **3. Start making API calls** You're ready to create campaigns, manage leads, and integrate LinkedCamp into your workflows. ## Response Format All API responses follow a consistent JSON structure: ```json theme={null} { "success": true, "message": "Descriptive message about the result", "data": {} } ``` | Field | Type | Description | | - | - | - | | `success` | boolean | Whether the request was successful | | `message` | string | A human-readable message describing the result | | `data` | object | The response payload (varies per endpoint) | # MCP for agencies Source: https://docs.linkedcamp.com/mcp/agencies Reach every sub-account you own from one assistant, with one owner key. An agency owner connects once and the assistant can then read any sub-account in that agency. There is no separate key per client and no signing in and out. Two things make that work: a tool that lists your accounts, and seven tools that accept one of those ids. ## 1. Get the roster [`subaccount_list`](/mcp/tools/subaccounts#subaccount_list) returns your active sub-accounts — id, name, email, plan and state. Owner-only; any other role is refused. An account is listed when it is enabled and on a plan. Disabled, deleted and not-yet-subscribed accounts are left out, and the response says how many were. ## 2. Name the account Seven tools take a `userId`. Pass one and they answer for that sub-account instead of yours: | Tool | Kind | What you get for that client | | - | - | - | | [`campaign_list`](/mcp/tools/campaigns#campaign_list) | Read-only | their campaigns and statuses | | [`linkedin_account_list`](/mcp/tools/accounts#linkedin_account_list) | Read-only | their LinkedIn accounts and session health | | [`email_account_list`](/mcp/tools/accounts#email_account_list) | Read-only | their connected mailboxes | | [`analytics_campaign`](/mcp/tools/analytics#analytics_campaign) | Read-only | campaign performance | | [`analytics_reporting`](/mcp/tools/analytics#analytics_reporting) | Read-only | the day-by-day series | | [`tag_list`](/mcp/tools/library#tag_list) | Read-only | reply tags and sentiment buckets | | [`agent_duplicate`](/mcp/tools/agents#agent_duplicate) | **Write** | copies an agent you built **into** that account | `agent_duplicate` is the only one that writes across accounts. It creates an agent inside the client's account, so name the client and get a yes first. > [!NOTE] > > Take the id from `subaccount_list`. Never construct or guess one — a wrong id > does not fail quietly, it names a different account. ## Records by id Beyond those seven, any tool that takes a record id — `campaignId`, `leadId`, `conversationId`, `linkedAccountId` — also works on a sub-account's records once you have the id. That includes writes such as [`campaign_update`](/mcp/tools/campaigns#campaign_update) and [`flow_set`](/mcp/tools/flows#flow_set), so an id is effectively full access to that record. ## What is enforced, and where Scoping is applied by the server, not hidden in an interface. Rephrasing a request does not widen it. * `userId` is accepted **only** from an agency owner key. * It is accepted **only** for an account inside your own agency. An id from outside your roster is refused with an error naming [`subaccount_list`](/mcp/tools/subaccounts#subaccount_list). * The sub-account list itself is scoped by the server to your own agency tree, and excludes you. * A record reached by id is checked against the accounts you own before it is read or written. Client accounts keep their own keys for their own assistants. Connecting your agency key changes nothing about what a client can see. ## Worth asking for Because one key reaches the whole roster, the useful questions are the ones that span clients: * "Which client campaigns had the worst reply rate this week?" * "Any LinkedIn sessions expired across my accounts?" * "Which clients have no active campaigns right now?" * "Copy my qualifier agent into the Acme account." The assistant will need to call `subaccount_list` first to know who it is comparing. Ask it to tell you which account each number belongs to — the tools return data per account, not a labelled roll-up. > [!NOTE] > > On the [ChatGPT plugin](/mcp/chatgpt-plugin) this needs release **1.2.8** or > later. Earlier releases ship a skill that predates `subaccount_list`, so > ChatGPT does not know to ask for the roster first. Overview for agencies: [LinkedCamp LinkedIn MCP server](https://www.linkedcamp.com/mcp). # ChatGPT plugin Source: https://docs.linkedcamp.com/mcp/chatgpt-plugin The official LinkedCamp plugin: what it installs, how it asks before acting, and what it will not do. > [card] [LinkedCamp for ChatGPT](https://chatgpt.com/plugins?search=linkedcamp) > > Run campaigns, work the inbox and pull analytics from a ChatGPT chat — no config file. For installation steps see the ChatGPT tab in the [quickstart](/mcp/quickstart). This page covers what the plugin is and how it behaves once connected. ## What it connects to The same hosted server every other client uses — the plugin is a listing, not a separate API: ```text theme={null} https://mcp.linkedcamp.com/mcp ``` Transport is Streamable HTTP. Authentication is OAuth 2.1 with PKCE: ChatGPT opens a LinkedCamp sign-in page and you paste your API key, which is the only credential that page accepts. The key is encrypted inside the access token and never appears in a URL or a log line. ## What ships in it | File | What it does | | - | - | | `plugin.json` | the public listing, prompts and review cases | | `mcp.json` | points ChatGPT at the hosted server | | `SKILL.md` | teaches ChatGPT the supported workflow and the safety rules below | `SKILL.md` is the part that matters in use. It gives ChatGPT the campaign build order, tells it which tool authors a sequence, and names the specific consequence of every destructive call — so it asks about the right thing rather than warning generically. ## It asks before anything irreversible Tools that reach a real person or destroy a record are flagged destructive in the protocol, so ChatGPT prompts before running them. The plugin treats that prompt as the floor, not the safeguard: the skill instructs it to state what will happen in specifics, get an explicit yes, and never put several destructive calls behind one confirmation. The ones whose effect is easy to misread, and which the skill spells out: | Tool | What actually happens | | - | - | | `message_send` | delivers to a real person immediately and cannot be recalled | | `message_delete` | edits **your** record only — the recipient keeps the message, it is not unsent | | `lead_blacklist` | excludes someone from every future campaign on the account, and nothing removes it | | `placeholder_delete` | copy using that merge field renders **empty with no error**, so live campaigns send with a hole in them | | `blacklist_delete` | people the rule was blocking — including opt-outs — become targetable again | | `agent_delete` | campaigns using it lose automated replies silently, so prospects mid-conversation stop getting answers | | `campaign_launch` | begins real outreach on the campaign schedule | > [!WARNING] > > `campaign_set_status` with `ACTIVE` restarts real outreach on a paused > campaign, but it is **not** destructive — it toggles a reversible field — so > no prompt appears. The skill tells ChatGPT to ask anyway, because a campaign > may have been paused for a reason you have not mentioned. ## What it will not do The skill lists these as unavailable so ChatGPT does not claim them or hunt for a substitute: * deleting a saved reply, a lead note, a sequence, an appointment or a notification * rotating your API key * archiving or completing a campaign — that is web-app housekeeping * connecting a LinkedIn account, which takes a password and a verification PIN * CRM integrations, and webhooks — manage those through the [Webhooks API](/api-reference/webhooks/create-webhook) It will also never ask for a LinkedIn password, session cookie, verification PIN or third-party API key in chat. Authentication belongs in the OAuth flow. ## Plan and permission limits apply The plugin reaches the same gated surface as any other client. Tools behind Pro or a named permission refuse on plan grounds, and sections your user permissions do not grant are hidden from the tool list and refused on the call. Ask ChatGPT to call `whoami` if a refusal is unclear — it reports the plan and the granted permissions under `_derived`. Agency owners get the same sub-account reach described in [MCP for agencies](/mcp/agencies). ## Versions The plugin is released from its own repository, and the ZIP attached to each release is what ChatGPT ingests. The current release is **1.2.8**. | Release | What it added | | - | - | | **1.2.8** | agency support — `subaccount_list` and the `userId` argument, so one owner key reaches every client account | | 1.2.7 | `message_send`, nine deletions and campaign pause/resume | The version matters because `SKILL.md` ships inside the ZIP. The tool list comes from the server, so an older install can still *call* a newer tool — it just has not been told the tool exists, or has been told the opposite. On 1.2.7 the skill described `userId` as accepted from any account owner and did not mention `subaccount_list`, so ChatGPT either omits the argument or guesses an id the server then refuses. Reinstall from the latest release if agency questions come back wrong or empty. # Claude connector Source: https://docs.linkedcamp.com/mcp/claude Connect LinkedCamp to Claude on the web, desktop and mobile: sign-in, access tiers, confirmations and disconnecting. > [card] [LinkedCamp for Claude](https://claude.ai/new#customize/connectors?q=linkedcamp) > > Build campaigns, work the inbox and pull analytics from a Claude chat. There is no config file to edit. LinkedCamp is listed in Claude's Connectors Directory. You connect it once on the web or desktop, and it then works in every Claude chat on web, desktop and mobile. ## What it connects to The same hosted server every other client uses: ```text theme={null} https://mcp.linkedcamp.com/mcp ``` Transport is Streamable HTTP. Authentication is OAuth 2.1 with PKCE: Claude opens a LinkedCamp sign-in page and you paste your API key, which is the only credential that page accepts. The key is encrypted inside the access token and never appears in a URL or a log line. ## Connect it **1. Find LinkedCamp in the directory** [Open LinkedCamp in Claude](https://claude.ai/new#customize/connectors?q=linkedcamp), or go to **Settings → Connectors**, choose **Browse connectors**, and search for **LinkedCamp**. On a Team or Enterprise plan, an owner may need to enable it for the organization first. **2. Connect** Open the LinkedCamp listing and click **Connect**. **3. Choose an access tier and sign in** Claude opens the LinkedCamp sign-in page. Pick **Full access**, **Read and write** or **Read only**, then paste your API key from [Settings → Integrations](https://app.linkedcamp.com/settings/integrations). The key is checked right away, so a typo fails on this page and not mid-conversation. **4. Use it** In a new chat, turn LinkedCamp on from the tools menu and ask: *"List my active campaigns and tell me which one has the best reply rate."* ### Can't find it in the directory? Add the same server as a custom connector instead. It uses the same sign-in and the same tools. 1. In **Settings → Connectors**, choose **Add custom connector**. 2. Name it `LinkedCamp` and paste `https://mcp.linkedcamp.com/mcp`. Leave the advanced OAuth fields empty. 3. Sign in as in step 3 above. If you added LinkedCamp as a custom connector before the directory listing, it keeps working. You don't need to switch. ## Access tiers The tier you choose at sign-in applies to that connection for as long as it lasts: | Tier | Tools | Use it for | | - | - | - | | **Read only** | 64 | Reporting and review. Changes nothing in your account. | | **Read and write** | 105 | Building and running campaigns, but no deleting and no sending a message by hand. | | **Full access** | 133 | Everything, including the destructive tools. | To change the tier, remove the connector and add it again. See [access tiers](/mcp/scope-and-safety#access-tiers) for the details. ## Claude asks before anything irreversible Every tool is marked as reading, writing or destructive. Claude can run read-only tools without asking, depending on your connector permission settings. Destructive tools, such as launching a campaign, sending a message or deleting a record, show a confirmation in Claude every time. You can tighten this per tool in **Settings → Connectors → LinkedCamp**, for example by setting every write tool to *Always ask*. > [!WARNING] > > `campaign_set_status` with `ACTIVE` restarts real outreach on a paused campaign. > It counts as a write and not as destructive, because pausing again undoes it, > so Claude may not prompt for it. Say "ask me before resuming anything" if you > want a confirmation. ## Plan and permission limits apply The connector reaches the same surface as any other client. Pro-only steps refuse on plan grounds, and sections your user permissions do not grant are hidden. Ask Claude to call `whoami` if a refusal is unclear. Agency owners get the sub-account reach described in [MCP for agencies](/mcp/agencies). ## Disconnect * **Remove the connector** in Claude under **Settings → Connectors**. * **Cut off every connection at once** by rotating your API key in [Settings → Integrations](https://app.linkedcamp.com/settings/integrations). Every token issued with the old key stops working immediately, in Claude and in every other client. ## Claude Code Claude Code can use the same OAuth flow, or it can send the key as a header with no browser step: ```bash theme={null} claude mcp add --transport http linkedcamp https://mcp.linkedcamp.com/mcp \ --header "X-Api-Key: YOUR_API_KEY" ``` See the [quickstart](/mcp/quickstart) for Cursor, Windsurf, Zed and local stdio. # Hermes Agent Source: https://docs.linkedcamp.com/mcp/hermes Run LinkedCamp from Hermes Agent with the LinkedCamp plugin — one browser sign-in, and Hermes asks before anything changes your account. > [card] [LinkedCamp plugin](https://github.com/LinkedCamp/hermes-plugin) > > The LinkedCamp connection, the outreach skill, and approval prompts before every change. > [card] [Hermes Agent](https://hermes-agent.nousresearch.com) > > Install Hermes first if you don't have it. The plugin talks to the same hosted server every other client uses: ```text theme={null} https://mcp.linkedcamp.com/mcp ``` ## Requirements * Hermes Agent **0.20** or newer * Node.js **20.18.1** or newer, with `npx` on your `PATH`. The plugin uses it to run the sign-in bridge. * A LinkedCamp account on an active plan. See the [quick start](/mcp/quickstart#1-get-your-api-key) for plan requirements. ## Install ```bash theme={null} hermes plugins install LinkedCamp/hermes-plugin --no-enable hermes plugins enable linkedcamp ``` ## Connect your account > [tab] Sign in (recommended) > > Start a new Hermes session. The first time the plugin starts, your browser opens the LinkedCamp sign-in page. Paste your API key and approve. > > Hermes keeps the token and refreshes it, so you sign in once. If the LinkedCamp tools don't appear after signing in, run `/reload-mcp`. > > To sign out, delete the `~/.mcp-auth` folder. > [tab] API key (headless) > > On a server or another machine with no browser, skip the plugin and add the server to `~/.hermes/config.yaml`: > > ```yaml theme={null} > mcp_servers: > linkedcamp: > url: "https://mcp.linkedcamp.com/mcp" > headers: > X-Api-Key: "${LINKEDCAMP_API_KEY}" > ``` > > Then put your key in `~/.hermes/.env`: > > ```bash theme={null} > LINKEDCAMP_API_KEY=your-api-key > ``` > > This connects LinkedCamp without the plugin's skill or approval prompts. Your API key is in [Settings → Integrations → API](https://app.linkedcamp.com/settings/integrations?type=api). Then ask Hermes: *"Which LinkedCamp account am I connected to?"* > [!WARNING] > > Never paste your API key into a chat. The agent is told not to ask for it; if a key does end up in a conversation, rotate it in Settings → Integrations. ## Approval prompts The plugin marks LinkedCamp as an untrusted server, so Hermes asks you before **every tool that changes something**: launching or resuming a campaign, sending a message or test email, editing a sequence, adding leads, scheduling a post, deleting records, and so on. Reading data goes through without a prompt. In unattended runs, such as scheduled jobs, Hermes refuses those tools instead of asking, so a scheduled job can report on LinkedCamp but can't change anything. The bundled skill also tells the agent to show you the audience and full sequence before a launch, and the exact text and recipient before a send. ## What you can do The agent reaches the [full tool surface](/mcp/overview#tool-groups) your plan and permissions allow. * Campaigns: build, generate LinkedIn and Sales Navigator audience searches, author multi-step sequences, launch after confirmation * Leads, notes, tags and blacklists * The unified inbox and reply drafts * AI reply agents and knowledge bases * LinkedIn post scheduling * Campaign, account and funnel analytics, including [agency sub-accounts](/mcp/agencies) Try: * *"Show me my LinkedCamp account and unread inbox counts."* * *"Build a draft campaign for heads of customer support at B2B SaaS companies. Show me the audience and the sequence before anything sends."* * *"Summarize my campaign performance for the last 30 days."* * *"Find my unread conversations, prioritize interested prospects and draft a reply for each. Don't send anything."* ## What it will not do * Connect a LinkedIn account — that takes your LinkedIn password, so do it in LinkedCamp * CRM integrations, billing, team management or API-key changes The agent will never ask for a LinkedIn password, session cookie or verification code. ## Versions The current release of the plugin is **1.0.0**. # OpenClaw Source: https://docs.linkedcamp.com/mcp/openclaw Run LinkedCamp from any chat OpenClaw is on — WhatsApp, Telegram, Slack, Discord or the Control UI — with approval prompts before anything reaches people. > [card] [LinkedCamp plugin](https://clawhub.ai/asveloper/plugins/linkedcamp) > > Recommended. The LinkedCamp connection, the skill, and approval prompts. > [card] [LinkedCamp skill](https://clawhub.ai/asveloper/skills/linkedcamp) > > The skill on its own. You connect LinkedCamp yourself, and there are no approval prompts. Both are published on ClawHub and talk to the same hosted server every other client uses: ```text theme={null} https://mcp.linkedcamp.com/mcp ``` ## Plugin or skill? | | Plugin | Skill only | | - | - | - | | Teaches the agent the LinkedCamp workflow | Yes | Yes | | Connects to LinkedCamp | You sign in once after installing | You add the MCP server yourself | | Asks before sending, launching or deleting | Yes — OpenClaw approval prompts | No — the conversation is the only check | Use the plugin unless you have a reason not to. ## Install Requires OpenClaw **2026.6.1** or newer. > [tab] Plugin (recommended) > > ```bash theme={null} > openclaw plugins install clawhub:@asveloper/linkedcamp > ``` > > On OpenClaw main/dev builds with ClawHub as the default source, the `clawhub:` prefix is optional. Stable releases through 2026.10.4 need it. > > ```bash theme={null} > openclaw plugins install @asveloper/linkedcamp > ``` > [tab] Skill only > > ```bash theme={null} > openclaw skills install @asveloper/linkedcamp > ``` > > The skill does not connect LinkedCamp for you — follow the next step as well. ## Connect your account > [tab] Sign in (recommended) > > ```bash theme={null} > openclaw mcp set linkedcamp '{"url":"https://mcp.linkedcamp.com/mcp","transport":"streamable-http","auth":"oauth"}' > openclaw mcp login linkedcamp > ``` > > The login prints a link. Open it, paste your API key into the LinkedCamp page, and approve. OpenClaw stores an encrypted token, not your key. > > If the Gateway runs on another machine and the browser cannot return to it, finish with: > > ```bash theme={null} > openclaw mcp login linkedcamp --code > ``` > > In the Control UI, the same flow is **Settings → MCP → linkedcamp → Sign in**. > [tab] API key (headless) > > For a Gateway with no browser, put your key in the Gateway environment, for example `~/.openclaw/.env`: > > ```bash theme={null} > LINKEDCAMP_API_KEY=your-api-key > ``` > > Then register the server. Keep the single quotes, so the shell leaves the variable for OpenClaw to fill in: > > ```bash theme={null} > openclaw mcp set linkedcamp '{"url":"https://mcp.linkedcamp.com/mcp","transport":"streamable-http","headers":{"X-Api-Key":"${LINKEDCAMP_API_KEY}"}}' > ``` > [tab] Teams > > On a shared Gateway, each chat member can sign in to their own LinkedCamp account: > > ```bash theme={null} > openclaw config set gateway.publicOrigin https://gateway.example.com > openclaw mcp set linkedcamp '{"url":"https://mcp.linkedcamp.com/mcp","transport":"streamable-http","auth":"oauth","oauth":{"identity":"per-requester"}}' > ``` Your API key is in [Settings → Integrations → API](https://app.linkedcamp.com/settings/integrations?type=api). See the [quick start](/mcp/quickstart#1-get-your-api-key) for plan requirements. Then check the connection: ```bash theme={null} openclaw mcp probe linkedcamp ``` and ask the agent: *"Which LinkedCamp account am I connected to?"* > [!WARNING] > > Never paste your API key into a chat. The agent is told not to ask for it; if a key does end up in a conversation, rotate it in Settings → Integrations. ## Approval prompts With the plugin installed, the agent asks you to **allow once** or **deny** before it: * **Reaches people** — launching or resuming a campaign, sending a message or test email, scheduling or publishing a LinkedIn post, changing posting slots, turning on an automation. * **Changes live outreach** — a campaign's audience, saving or editing a sequence, attaching an agent, editing an active agent, knowledge-base entry or persona, overwriting templates, saved replies or notes, skipping a scheduled step. * **Removes data** — deleting campaigns, leads, messages, agents, knowledge, personas, tags, blacklist rules, merge fields, blocked dates or reminders, and blacklisting a lead. Reading data, building a draft campaign, adding leads, private draft posts, and inactive agents or automations go through without a prompt. Approve in the Control UI, with `/approve`, or in the chat the request was routed to. > [!NOTE] > > With the skill alone there are no approval prompts. The agent is instructed to confirm in the conversation, but nothing enforces it. ### Plugin settings Set under `plugins.entries.linkedcamp.config`: | Setting | Default | What it does | | - | - | - | | `requireApproval` | `true` | Set `false` to turn approval prompts off. Not recommended. | | `serverName` | `"linkedcamp"` | Change only if you connected LinkedCamp under another name. | ### Hide tools entirely To take tools away from the agent instead of approving them one by one: ```bash theme={null} openclaw mcp tools linkedcamp --exclude 'message_send,campaign_launch,*_delete,lead_blacklist' ``` ## What you can do The agent reaches the [full tool surface](/mcp/overview#tool-groups) your plan and permissions allow. Tools appear in OpenClaw as `linkedcamp__` — for example `linkedcamp__whoami` or `linkedcamp__campaign_list`. * Campaigns: build, generate LinkedIn and Sales Navigator audience searches, author multi-step sequences, launch after confirmation * Leads, notes, tags and blacklists * The unified inbox and reply drafts * AI reply agents and knowledge bases * LinkedIn post scheduling * Campaign, account and funnel analytics, including [agency sub-accounts](/mcp/agencies) Try: * *"Show me my LinkedCamp account and unread inbox counts."* * *"Build a draft campaign for heads of customer support at B2B SaaS companies. Show me the audience and the sequence before anything sends."* * *"Summarize my campaign performance for the last 30 days."* * *"Find my unread conversations, prioritize interested prospects and draft a reply for each. Don't send anything."* ## What it will not do * Connect a LinkedIn account — that takes your LinkedIn password, so do it in LinkedCamp * CRM integrations, billing, team management or API-key changes The agent will never ask for a LinkedIn password, session cookie or verification code. ## Versions The current release of both the plugin and the skill is **1.0.4**. # MCP server Source: https://docs.linkedcamp.com/mcp/overview Drive LinkedCamp from Claude, ChatGPT, OpenClaw, Hermes Agent, Cursor or any MCP client. The LinkedCamp MCP server exposes your account through the [Model Context Protocol](https://modelcontextprotocol.io). Describe what you want in natural language and the assistant builds campaigns, works your inbox and pulls analytics for you. New to it? See what the [LinkedIn MCP server](https://www.linkedcamp.com/mcp) does for lead gen agencies. ```text Endpoint theme={null} https://mcp.linkedcamp.com/mcp ``` It uses the remote **Streamable HTTP** transport and authenticates with your LinkedCamp API key, so it acts as you, with your permissions. There is nothing new to provision. > [card] [133 tools](#tool-groups) > > 64 read-only, 69 write and 28 destructive. > [card] [Launch end to end](/mcp/sequences) > > Create a campaign, attach accounts, author a branching sequence and start it in one conversation. > [card] [Your API key](/mcp/quickstart) > > The same key as the REST API. Claude, ChatGPT, OpenClaw and Hermes Agent sign in with it over OAuth. ## Connect your assistant > [card] [Claude](/mcp/claude) > > Connect it from Claude's Connectors Directory, sign in once, and use it on web, desktop and mobile. > [card] [ChatGPT](/mcp/chatgpt-plugin) > > Install the LinkedCamp plugin and sign in. There is no config file to edit. > [card] [OpenClaw](/mcp/openclaw) > > Run LinkedCamp from WhatsApp, Telegram, Slack, Discord or the Control UI. > [card] [Hermes Agent](/mcp/hermes) > > Sign in once in the browser. Hermes asks before anything changes your account. Using Claude Code, Cursor, Windsurf, Zed or another MCP client? Follow the [quickstart](/mcp/quickstart). ## What you can ask for * "List my active campaigns and tell me which one has the best reply rate." * "Build a campaign targeting RevOps leaders at Series B SaaS companies, with a connect note, a follow-up message and an email fallback." * "Go through unread replies, classify them and draft responses for me to approve." * "Give me a week-over-week summary across all campaigns." ## Tool groups If a tool isn't listed in these groups, the server doesn't offer it. > [card] [Core](/mcp/tools/core) > > `whoami`, `reference` and unread counts. Start here. (3) > [card] [Campaigns](/mcp/tools/campaigns) > > Create, configure, source prospects, launch, pause and resume. (19) > [card] [Flows and sequences](/mcp/tools/flows) > > Author a campaign's sequence and inspect each step. (9) > [card] [Leads and activities](/mcp/tools/leads) > > Prospects, notes and their scheduled actions. (14) > [card] [Sending accounts](/mcp/tools/accounts) > > LinkedIn accounts, mailboxes and safety limits. (13) > [card] [Unified inbox](/mcp/tools/inbox) > > Conversations, saved replies, AI-drafted replies and sending. (9) > [card] [Analytics](/mcp/tools/analytics) > > Campaign, account and trend reporting. (5) > [card] [Library](/mcp/tools/library) > > Tags, blacklists, templates, merge fields and holidays. (20) > [card] [Personas](/mcp/tools/personas) > > Ideal-customer definitions for `QUALIFIER` steps. (5) > [card] [AI agents](/mcp/tools/agents) > > Reply agents and their knowledge base. (13) > [card] [Content](/mcp/tools/content) > > LinkedIn posts and the publishing calendar. (6) > [card] [CRM and follow-up](/mcp/tools/crm) > > Tasks, appointments and reminders. (7) > [card] [Automations](/mcp/tools/automation) > > Account-wide, event-driven workflows. (4) > [card] [Account settings](/mcp/tools/settings) > > Notifications, profile preferences and team roster. (5) > [card] [Sub-accounts](/mcp/tools/subaccounts) > > List the accounts under your agency. Owner-only. (1) > [!NOTE] > > Each tool is tagged **read-only**, **write** or **destructive** in the protocol. Destructive tools, which launch campaigns, send messages, publish posts or delete records, make your client ask for confirmation first. See [Scope and safety](/mcp/scope-and-safety). # Quick start Source: https://docs.linkedcamp.com/mcp/quickstart Get your API key, add the endpoint to your MCP client and start chatting. ## 1. Get your API key **1. Open Integrations** In the LinkedCamp app, go to [Settings → Integrations → API](https://app.linkedcamp.com/settings/integrations?type=api). API access needs a plan with Pro features (Pro or Agency) and the **Integrations** permission. **2. Copy the API key** It's a UUID, for example `3f7c1a92-8e4b-4d1f-9c0a-2b5e8d4f6a11`. **3. Keep it secret** Treat it like a password. Rotate it from the same page if it ever leaks. > [!WARNING] > > The key acts as you. Anyone who has it can launch campaigns and send messages from your account. Rotating it from Integrations invalidates the old key immediately. Billing, agency admin and team management stay blocked on the server whatever the key. ## 2. Connect your client > [!NOTE] > > However you connect, the sign-in page asks what the connection should be > allowed to do: **Read only**, **Read and write**, or **Full access**. Full > access is pre-selected; pick a narrower tier to hand an assistant a > reporting-only or non-destructive connection. See > [access tiers](/mcp/scope-and-safety#access-tiers). > [tab] Claude > > LinkedCamp is listed in Claude's Connectors Directory. Connect it on the web or desktop and sign in. You don't paste the key into a config file. > > **1. Find LinkedCamp** > > [Open LinkedCamp in Claude](https://claude.ai/new#customize/connectors?q=linkedcamp), or go to **Settings → Connectors → Browse connectors** and search for **LinkedCamp**. > > **2. Connect** > > Open the listing and click **Connect**. > > **3. Authorize** > > Claude opens a LinkedCamp sign-in page. Paste your API key. It's the only credential the page accepts. > > **4. Use it** > > Start a chat: *"List my active campaigns and tell me which one has the best reply rate."* > > Not in the directory for you? Choose **Add custom connector** and paste `https://mcp.linkedcamp.com/mcp` instead. > > > [!TIP] > > > > The connector uses OAuth 2.1 with PKCE. Your API key is encrypted inside the access token and never appears in a URL or a log line. > > See [Claude connector](/mcp/claude) for access tiers, confirmations and disconnecting. > [tab] Claude Code > > Register the remote HTTP server from the terminal: > > ```bash theme={null} > claude mcp add --transport http linkedcamp https://mcp.linkedcamp.com/mcp \ > --header "X-Api-Key: YOUR_API_KEY" > ``` > > Then check that it registered: > > ```bash theme={null} > claude mcp list > ``` > [tab] Cursor / Windsurf / Zed > > Add the server to your MCP config. For Cursor, that's `~/.cursor/mcp.json`: > > ```json theme={null} > { > "mcpServers": { > "linkedcamp": { > "url": "https://mcp.linkedcamp.com/mcp", > "headers": { "X-Api-Key": "YOUR_API_KEY" } > } > } > } > ``` > [tab] ChatGPT > > The easiest way is the official plugin: > > > [card] [LinkedCamp for ChatGPT](https://chatgpt.com/plugins?search=linkedcamp) > > > > Install the plugin to run campaigns, work the inbox and pull analytics from a ChatGPT chat, with no config file. > > You can also add the server as a custom connector: > > **1. Open connector settings** > > **Settings → Connectors** → add a custom connector using the Streamable HTTP transport. > > **2. Paste the endpoint** > > ```text theme={null} > https://mcp.linkedcamp.com/mcp > ``` > > **3. Authorize** > > ChatGPT opens a LinkedCamp sign-in page. Paste your API key. It's the only credential the page accepts. > > **4. Use it** > > Start a chat: *"Show me the campaigns that replied best this month."* > > > [!NOTE] > > > > Custom connectors aren't available on every ChatGPT plan, and on some they're behind developer mode. If you can't see the option, check your plan. > [tab] OpenClaw > > Install the plugin from ClawHub, then sign in: > > ```bash theme={null} > openclaw plugins install clawhub:@asveloper/linkedcamp > openclaw mcp set linkedcamp '{"url":"https://mcp.linkedcamp.com/mcp","transport":"streamable-http","auth":"oauth"}' > openclaw mcp login linkedcamp > ``` > > The login prints a link where you paste your API key. For headless Gateways, team setups and the skill-only install, see [OpenClaw](/mcp/openclaw). > [tab] Hermes Agent > > Install and enable the plugin: > > ```bash theme={null} > hermes plugins install LinkedCamp/hermes-plugin --no-enable > hermes plugins enable linkedcamp > ``` > > Start a new session. Your browser opens the LinkedCamp sign-in page, where you paste your API key. Needs Node.js 20.18.1 or newer. For a headless setup with an API key, see [Hermes Agent](/mcp/hermes). ## 3. First conversation Ask the assistant to call `whoami` first. It reports your plan and permissions, which decide which tools and sequence steps you can use. Then try: * *"Which of my campaigns has the best acceptance rate this month?"* * *"Draft replies to my unread interested leads."* * *"Create a draft campaign for CTOs in fintech and show me the sequence before launching."* ## Authentication | Client type | How the key is sent | | - | - | | Claude and ChatGPT connectors, OpenClaw and Hermes Agent sign-in | OAuth 2.1 + PKCE. You paste the key once on the LinkedCamp sign-in page. | | Config-file clients (Claude Code, Cursor, Windsurf, Zed, headless OpenClaw and Hermes Agent) | `X-Api-Key` HTTP header on every request. | Overview for agencies: [LinkedCamp LinkedIn MCP server](https://www.linkedcamp.com/mcp). # Scope and safety Source: https://docs.linkedcamp.com/mcp/scope-and-safety What the MCP server can and cannot do, which tools contact real people, and the built-in prompts and resources. ## Available * Campaigns, sequences and flows * Prospects, activities and notes * The unified inbox — reading, AI-drafted replies and sending * LinkedIn and email account settings * Tags, blacklists, templates, merge fields * Personas and AI agents * LinkedIn posts and scheduling * Analytics and reporting * Tasks, appointments, reminders * Account-wide automations ## Not available These operations are not exposed by any tool, whatever the request says. | Area | Why | | - | - | | Billing — subscriptions, plans, payment methods, invoices, coupons | Money movement is never delegated to an integration | | Agency and sub-account administration, licences, impersonation | Account-owner actions with cross-tenant reach | | Tenant / white-label configuration | Platform configuration, not account data | | Team invitations, role changes, session revocation | Membership is an account-owner action | | Account deletion, trial termination, cross-account campaign moves | Irreversible and out of an integration's remit | | Reading back stored credentials — LinkedIn passwords, mailbox tokens, integration API keys | Excluded from every selection set; no tool returns them | | Connecting a LinkedIn account, PIN verification, mailbox OAuth callbacks | Take passwords, PINs and OAuth codes; belong in a browser | | CRM integrations — connecting, reading, field mapping, pushing a lead | Connecting one takes a third-party credential; configure integrations in the web app | | Deleting a saved reply or a lead note, a sequence, an appointment or a notification | Irreversible record loss with no safer equivalent; campaign, holiday, reminder and the AI-library deletions are available with confirmation | | Rotating the API key | Invalidates the key the connector is using, cutting its own connection mid-session | | Archiving or completing a campaign | Web-app housekeeping with no outreach meaning; pause and resume are available with confirmation | > [!NOTE] > > Exclusions are enforced on the server. An API key that asks for a blocked operation gets `403 FORBIDDEN` regardless of how the request is phrased — the check inspects the GraphQL root field being executed, not the label on the request. ## Access tiers When you connect, the sign-in page asks what the connection should be allowed to do. The choice applies for the life of that connection: tools outside the tier are hidden from `tools/list` and refused if called anyway. | Tier | Tools | What it can do | | - | - | - | | **Read only** | 64 | Reporting and review. Changes nothing in your account. | | **Read and write** | 105 | Build and run campaigns. Cannot delete anything or send a message by hand. | | **Full access** | 133 | Everything, including the [destructive tools](#destructive-tools) below. | Reading is available at every tier, including Read only — so an assistant can always report on campaigns, read the inbox and pull analytics. There is no write-without-read option, because writing here requires reading first: changing a campaign needs the campaign's id, and a sequence is validated against the campaign it belongs to. > [!NOTE] > > **Full access is pre-selected.** It is what every connection did before this > choice existed. Pick a narrower tier if you want one — nothing is restricted > unless you choose it. A tier only ever subtracts. It cannot grant anything your plan or permissions do not already allow, and Full access does not switch off the confirmation prompts on destructive tools. To change the tier, reconnect the integration and pick a different one. Connections made before this option existed keep working with full access until you reconnect. ## Permissions Each tool group is tied to a section permission on your account (Campaigns, Accounts, Inbox, Reporting, Personas, Agents, Publish, Tasks, Automations). If your plan or team role does not grant a section, the server hides its tools from `tools/list` and refuses them on call. Pro-only sequence steps (`EMAIL`, `QUALIFIER`, `GPT`, `FINDER`, `EVENT`) are refused on plans without Pro features — call [`whoami`](/mcp/tools/core#whoami) to see what is locked. > [!NOTE] > > Account owners have no section restrictions, so this never narrows an owner's > tool list. To trim it deliberately, see [choosing a smaller tool > list](#choosing-a-smaller-tool-list). ## Choosing a smaller tool list The full server advertises 133 tools. Some clients are slower to start with a large tool list, because they read every tool definition before answering anything. Add `toolsets` to the server URL to carry only the groups you want: ```text theme={null} https://mcp.linkedcamp.com/mcp?toolsets=campaigns,flows,analytics ``` | Group | What it covers | | - | - | | `campaigns` | campaigns, prospect sourcing, launching | | `flows` | sequences and templates | | `leads` | prospects and activity | | `accounts` | LinkedIn accounts and mailboxes | | `inbox` | conversations and replies | | `analytics` | reporting | | `library` | tags, templates, placeholders, blacklist | | `personas` · `agents` · `content` · `crm` · `automation` · `settings` | as named | A few things worth knowing: * **Leaving it off gives you everything**, which is the default. * **`whoami` and `reference` are always included**, whatever you choose — without them a client cannot read your plan or build a valid request. * **A name we do not recognise is ignored.** If none of the names match, you get the full list rather than an empty one, so a typo cannot leave you with a connection that does nothing. * **This is not a permission.** It only decides what this connection carries; it cannot reach anything your account does not already allow, and it does not change what the [access tier](#access-tiers) permits. If a tool you need is missing, ask the assistant to call `whoami` — it reports what the connection carries under `_derived.connection`, so it can tell you whether a tool is withheld by this setting or by your plan. ## Destructive tools These tools contact real people or delete records permanently. Each is marked **destructive** in the protocol, so your MCP client asks for confirmation before running it. | Tool | What happens | | - | - | | `campaign_launch` | Outreach starts sending on the campaign schedule | | `campaign_delete` | Moves the campaign to DELETED so it stops appearing — reversible in the database, not from here | | `flow_set on an ACTIVE campaign` | Re-evaluates every lead against the new sequence and can cancel pending actions | | `campaign_send_test_email` | Sends a real email | | `post_upsert with a due scheduledAt` | Publishes to LinkedIn publicly | | `message_send` | Delivers to a real person on LinkedIn or by email immediately — cannot be recalled | | `lead_delete` | Removes leads and their pending actions permanently | | `lead_blacklist` | Excludes someone from every future campaign on the account; nothing removes it | | `message_delete` | Removes a message from your record only — the recipient keeps it, it is not unsent | | `agent_delete` | Campaigns using it lose automated replies, so prospects mid-conversation stop getting answers | | `kb_delete` | Source material is gone — a crawled page must be crawled again | | `persona_delete` | Breaks every QUALIFIER step pointing at it; those flows then fail to save | | `tag_delete` | Leads lose the classification and past reply-sentiment reporting changes | | `blacklist_delete` | People the rule was blocking — including opt-outs — become targetable again | | `placeholder_delete` | Copy using the merge field renders empty with no error, so live campaigns send with a hole in them | > [!WARNING] > > Editing a live campaign's sequence with `flow_set` re-evaluates every lead already in flight. Call [`flow_audit`](/mcp/tools/flows#flow_audit) straight afterwards to see exactly what changed. ## Built-in prompts The server publishes these MCP prompts. Clients that support prompts show them as slash commands or templates. | Prompt | What it does | | - | - | | `launch-campaign` | Plans and launches a campaign, with a mandatory review step | | `campaign-health-check` | Diagnoses an underperforming campaign and proposes fixes | | `triage-inbox` | Classifies unread replies and drafts responses for approval | | `weekly-report` | Cross-campaign performance summary with week-over-week movement | | `clone-and-retarget` | Copies a working campaign onto a new audience | ## Resources | URI | Title | Description | | - | - | - | | `mcp://reference/schema` | Platform vocabulary | Every enum the API accepts — call the reference tool or read this resource. | | `mcp://guide/campaign-playbook` | Campaign building playbook | Full build-a-campaign walkthrough with a worked example. | | `mcp://guide/safety` | Scope and safety | What the assistant will do only after asking, and what is never available. | # Sequences Source: https://docs.linkedcamp.com/mcp/sequences The step objects accepted by flow_set — step types, fields, branch conditions and a worked example. The `steps` parameter on [`flow_set`](/mcp/tools/flows#flow_set) takes an ordered array of step objects. `delay` is measured from completion of the previous step, not from launch. > [!TIP] > > Call [`reference`](/mcp/tools/core#reference) with `topic: "sequence_steps"` or `"triggers"` before authoring a sequence. It returns the live vocabulary the server validates against. ## Step types | Type | Required fields | Needs | | - | - | - | | `CONNECT` | note (≤300 chars) or connectWithoutMessage: true | LinkedIn account | | `MESSAGE` | message | LinkedIn account | | `INMAILS` | message (subject recommended) | LinkedIn account | | `VOICE` | message — the script for the voice note | LinkedIn account | | `EMAIL` | subject + message | mailbox, Pro plan | | `ENGAGEMENT` | — (postsToLike / commentsToAdd / skillsToEndorse, default 2/0/0) | LinkedIn account | | `FOLLOW` | — | LinkedIn account | | `FOLLOW_COMPANY` | followCompanyUrl | LinkedIn account | | `EVENT` | eventUrl | LinkedIn account, Pro plan | | `EVENT_MESSAGE` | message | LinkedIn account | | `GROUP_MESSAGE` | message | LinkedIn account | | `WITHDRAW` | — (delay in days since the invite, default 7) | LinkedIn account | | `TASK` | title | — | | `API` | — (fires the campaign webhook) | — | | `GPT` | instructions (+ provider, model) | Pro plan, AI provider | | `FINDER` | — (enriches the lead with an email address) | Pro plan | | `QUALIFIER` | personaId | Pro plan, AI provider | | `SEND_TO_CAMPAIGN` | newCampaignId | — | | `ASSIGN_TAG` | tagId | — | | `TRIGGER` | trigger (+ optional yes / no branches) | — | ## Step fields | Field | Type | Applies to | Description | | - | - | - | - | | `type` | enum | all | Which step this is. Required. | | `delay` | integer (0–365) | all | Wait after the previous step completes. Default 1, or the trigger default for TRIGGER. | | `delayType` | days \| hours \| minutes | all | Unit for delay. Default days. | | `note` | string (≤300) | CONNECT | The invitation note. LinkedIn caps this at 300 characters, or 200 without Premium. | | `shortNote` | string (≤200) | CONNECT | Fallback note used once the account exhausts its long-note allowance. | | `connectWithoutMessage` | boolean | CONNECT | Send a bare invitation. Higher accept rate, no personalisation. | | `subject` | string | EMAIL, INMAILS | Subject line. | | `message` | string | MESSAGE, EMAIL, INMAILS, VOICE, GROUP\_MESSAGE, EVENT\_MESSAGE | Body. Supports \{\{firstName}}-style merge fields. | | `attachment` | object | messaging steps | \{ url, name?, type? }. Must already be hosted at a publicly reachable URL the platform can fetch. | | `useCredits` | boolean | INMAILS | Spend InMail credits when the lead is not an Open Profile. | | `abTestingEnabled` | boolean | messaging steps | Split traffic between the A copy and the B copy. | | `bNote / bShortNote / bSubject / bMessage` | string | messaging steps | Variant B copy. Required when abTestingEnabled is set. | | `postsToLike` | integer (0–10) | ENGAGEMENT | Recent posts to like. Default 2. | | `commentsToAdd` | integer (0–10) | ENGAGEMENT | Posts to comment on. Default 0. | | `skillsToEndorse` | integer (0–10) | ENGAGEMENT | Skills to endorse. Default 0. | | `followCompanyUrl` | string | FOLLOW\_COMPANY | LinkedIn company page to follow. | | `eventUrl` | string | EVENT | LinkedIn event to invite the lead to. | | `newCampaignId` | string | SEND\_TO\_CAMPAIGN | Campaign to move the lead into. | | `tagId` | string | ASSIGN\_TAG | Tag to apply. See tag\_list. | | `provider / model` | string | GPT | Which connected AI provider and model to call. | | `instructions` | string | GPT | Prompt used to draft the personalised opener. | | `personaId` | string | QUALIFIER | Persona to score the lead against. Required — the flow save fails without it. | | `mismatchAction` | enum | QUALIFIER | NONE \| TAG \| MARK\_NOT\_QUALIFIED \| REMOVE\_FROM\_CAMPAIGN. Default MARK\_NOT\_QUALIFIED. | | `mismatchNext` | CONTINUE \| STOP | QUALIFIER | Whether a mismatched lead continues down the flow. Default STOP. | | `title` | string | TASK | What your team should do. | | `trigger` | enum | TRIGGER | The branch condition. | | `prompt / branches` | string / object\[] | TRIGGER CUSTOM | Classification prompt and the two branch labels. | | `yes / no` | step\[] | TRIGGER | Steps to run on each branch. Omit one to end the sequence there. | ## Merge fields Available in note, shortNote, subject and message: `{{firstName}}`, `{{lastName}}`, `{{designation}}`, `{{location}}`, `{{companyName}}`, `{{industry}}`, `{{senderName}}`, `{{signature}}` — plus anything from placeholder\_list and any CSV column mapped to customVariable. ## Branch conditions A `TRIGGER` step branches on one of these conditions. Put the steps for each outcome under `yes` and `no`. | trigger | Condition | Default wait | | - | - | - | | `If_Replied` | If replied | 1 days | | `If_Connected` | If connection accepted | 1 days | | `If_Interested` | If reply classified as interested (Pro) | 0 days | | `If_InMail_Open` | If InMail opened | 0 days | | `If_Email_Exists` | If an email address was found | 0 days | | `If_Email_Opened` | If email opened | 1 days | | `If_Email_Bounced` | If email bounced | 1 days | | `If_Link_Clicked` | If a tracked link was clicked | 1 days | | `If_Visited_Profile` | If the lead viewed your profile | 1 days | | `CUSTOM` | AI Decision Maker — classify with an LLM (Pro) | 0 days | > [!TIP] > > A `TRIGGER` is always the last entry in its list — anything that comes after it goes under `yes` or `no`. An omitted branch simply ends the sequence for that lead. ## Example sequence Connect with a note, then branch on acceptance. Accepted leads get a LinkedIn message and, if they don't reply, an email. Leads who don't accept within two weeks have their invitation withdrawn. ```json theme={null} [ { "type": "CONNECT", "delay": 0, "note": "Hi {{firstName}} — noticed you're running RevOps at {{companyName}}. Mind if I share how similar teams cut CRM admin?" }, { "type": "TRIGGER", "trigger": "If_Connected", "delay": 2, "yes": [ { "type": "MESSAGE", "delay": 1, "message": "Thanks for connecting, {{firstName}}. How are you handling pipeline hygiene today?" }, { "type": "TRIGGER", "trigger": "If_Replied", "delay": 4, "no": [ { "type": "EMAIL", "delay": 3, "subject": "The teardown I mentioned", "message": "Hi {{firstName}},\n\nSending this over in case LinkedIn is not where you live." } ] } ], "no": [ { "type": "WITHDRAW", "delay": 14 } ] } ] ``` # Sending accounts Source: https://docs.linkedcamp.com/mcp/tools/accounts The LinkedIn accounts and mailboxes that campaigns actually send from, and their safety limits. > [!NOTE] > > Requires the **Accounts** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`email_account_add_imap`](#email_account_add_imap) | Write | | [`email_account_get`](#email_account_get) | Read-only | | [`email_account_list`](#email_account_list) | Read-only | | [`email_account_oauth_url`](#email_account_oauth_url) | Read-only | | [`email_account_stats`](#email_account_stats) | Read-only | | [`email_account_update`](#email_account_update) | Write | | [`linkedin_account_daily_stats`](#linkedin_account_daily_stats) | Read-only | | [`linkedin_account_get`](#linkedin_account_get) | Read-only | | [`linkedin_account_list`](#linkedin_account_list) | Read-only | | [`linkedin_account_refresh`](#linkedin_account_refresh) | Write | | [`linkedin_account_ssi`](#linkedin_account_ssi) | Read-only | | [`linkedin_account_stats`](#linkedin_account_stats) | Read-only | | [`linkedin_account_update`](#linkedin_account_update) | Write | ## email\_account\_add\_imap Write Connect a mailbox over IMAP/SMTP with a username and password. Google and Microsoft mailboxes should go through `email_account_oauth_url` instead — OAuth avoids storing a password and survives 2FA. Requires a Pro or Agency plan. ### Parameters **email** `string (email)` *required* Email address. **password** `string` *required* Mailbox or app-specific password. **firstName** `string` Given name. **lastName** `string` Family name. **imap** `object` *required* IMAP/SMTP connection details. **properties** **incomingServer** `string` *required* IMAP host, e.g. "imap.fastmail.com". **incomingServerPort** `integer` *required* Usually 993. **outgoingServer** `string` *required* SMTP host. **outgoingServerPort** `integer` *required* Usually 465 or 587. ## email\_account\_get Read-only Detail for one mailbox: sending limits, warm-up state, signature and IMAP/SMTP settings. Settings as configured; for what the mailbox actually sent use `email_account_stats`. Change any of it with `email_account_update`. ### Parameters **emailAccountId** `string` *required* Mailbox id, from `email_account_list`. ## email\_account\_list Read-only Mailboxes connected for email steps (Google, Microsoft or IMAP). A campaign with an EMAIL step needs at least one attached via `campaign_update` → `emailAccountIds`. Unlike the single LinkedIn account, several mailboxes are allowed and sends rotate across them — ask the user which, do not attach all of them. Connecting a new one is `email_account_oauth_url` (Google/Microsoft) or `email_account_add_imap`, both Pro-only. ### Parameters **keyword** `string` Free-text search. **status** `string` Filter by status. **userId** `string` Sub-account owner id. Omit to act on your own data. ## email\_account\_oauth\_url Read-only Build the Google or Microsoft consent URL for connecting a mailbox. Hand the URL to the user to open in a browser — the OAuth callback is completed by the web app, not by MCP, so returning the URL is the whole job and the mailbox will not appear in `email_account_list` until they finish. Preferred over `email_account_add_imap` for Google and Microsoft: no password is stored and it survives 2FA. There is no equivalent for LinkedIn accounts. Requires a Pro or Agency plan. ### Parameters **provider** `GOOGLE | MICROSOFT` *required* Which connected AI provider to use. Providers are connected in the web app. **state** `string` *required* Opaque value echoed back on the callback. Use the user id or any correlation token. ## email\_account\_stats Read-only Sends, opens, clicks and bounces for one mailbox over a date range. Per mailbox, which is the right view when diagnosing deliverability. For the same numbers per campaign use `analytics_campaign`. ### Parameters **emailAccountId** `string` *required* Mailbox id, from `email_account_list`. **range** `object` Date window as \{ from, to } — epoch milliseconds or ISO 8601. Omit for the backend default. **properties** **from** `string | number` Start of the window. **to** `string | number` End of the window. **startDate** `string | number` Alias for `from`. **endDate** `string | number` Alias for `to`. ## email\_account\_update Write Change sending behaviour for a mailbox: daily volume, the gap between sends, reply-to address, signature, warm-up and pause state. Affects every campaign using the mailbox, not one campaign. It cannot connect a mailbox (`email_account_oauth_url`, `email_account_add_imap`) or choose which campaign uses it (`campaign_update`). Raising daily volume on a cold mailbox risks deliverability — leave warm-up alone unless asked. ### Parameters **emailAccountId** `string` *required* Mailbox id, from `email_account_list`. **emailsPerDay** `integer (1–1000)` Daily send ceiling for this mailbox. **delay** `integer (min 0)` Minutes to wait between consecutive sends. **replyTo** `string (email)` Address replies are delivered to, when it differs from the sending address. **signature** `string` HTML signature appended to outgoing mail. **isWarmup** `boolean` Ramp volume up gradually instead of starting at the full limit. **isPaused** `boolean` Pause without deleting. **firstName** `string` Given name. **lastName** `string` Family name. ## linkedin\_account\_daily\_stats Read-only Day-by-day action counts for a LinkedIn account. Use this to check how close an account is running to its daily ceilings before raising limits. Read this before `linkedin_account_update` ever touches `limits` — it is the evidence for whether there is headroom. It reports what was sent; the ceilings themselves are in `linkedin_account_get`. ### Parameters **linkedAccountId** `string` Omit to aggregate across all accounts. **startDate** `string | number` Window start, as epoch milliseconds or an ISO 8601 string. **endDate** `string | number` Window end, as epoch milliseconds or an ISO 8601 string. ## linkedin\_account\_get Read-only Full detail for one LinkedIn account, including its per-action daily limits and warm-up state. Configuration as it stands, not activity: for volumes sent use `linkedin_account_stats`, for today's headroom against the caps `linkedin_account_daily_stats`. Like the list, it cannot tell you whether the account has a Sales Navigator or Recruiter seat — ask the user. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. ## linkedin\_account\_list Read-only The LinkedIn accounts connected to this account. A campaign sends from exactly one of them, attached via `campaign_update`; if there is more than one, ask the user which. Whether an account has a Sales Navigator or Recruiter seat is NOT in this output — those flags exist on the account record but are not exposed by the API, and the worker only sets them during a send. Ask the user, because INMAILS steps and `/sales/` or `/talent/` lead sources depend on it. Check `isValid`, `isPaused`, `accountRestricted` and `weeklyLimitReached` before assigning an account — a campaign attached to a broken account will launch but never send. This lists; it does not connect. Adding a LinkedIn account takes a password and a verification PIN and has no tool at all — it is done in the web app. Attaching an existing account to a campaign is `campaign_update`, and changing the account's own limits is `linkedin_account_update`. ### Parameters **keyword** `string` Filter by name or email. **status** `string` Backend-side status filter, e.g. "active", "paused", "invalid". **userId** `string` Sub-account owner id. Omit for your own accounts. ## linkedin\_account\_refresh Write Re-establish the browser session for a LinkedIn account after it goes invalid. May return `pinDetected: true`, meaning LinkedIn is asking for a verification PIN — that has to be entered in the web app; MCP cannot complete it — tell the user plainly rather than retrying. It repairs the session only. It does not change settings (`linkedin_account_update`), connect a new account, or clear a LinkedIn-imposed restriction — check `accountRestricted` in `linkedin_account_list` for that. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. ## linkedin\_account\_ssi Read-only The account's latest LinkedIn SSI score and its four component scores. LinkedIn's own measure of selling activity, nothing to do with campaign performance — for that use `analytics_campaign` or `linkedin_account_stats`. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. ## linkedin\_account\_stats Read-only Send volumes, acceptance and reply rates for one LinkedIn account over a date range. Totals for the window, by account. For one campaign instead use `analytics_campaign`, and for a day-by-day breakdown `linkedin_account_daily_stats`. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. **range** `object` Date window as \{ from, to } — epoch milliseconds or ISO 8601. Omit for the backend default. **properties** **from** `string | number` Start of the window. **to** `string | number` End of the window. **startDate** `string | number` Alias for `from`. **endDate** `string | number` Alias for `to`. ## linkedin\_account\_update Write Change the safety limits and automation settings on a LinkedIn account: daily caps per action, pause/resume, warm-up, and the birthday / work-anniversary / role-change auto-congratulation messages. Raising daily limits raises LinkedIn restriction risk — leave `limits` alone unless the user asked for a specific number, and check `linkedin_account_daily_stats` first. Scope is the account, so pausing here stops every campaign that sends from it — to stop one campaign there is no tool, and to stop one lead use `lead_update`. It cannot connect or disconnect an account, fix an invalid session (`linkedin_account_refresh`), or decide which campaign uses it (`campaign_update`). ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. **limits** `object` Daily ceilings per action type. **properties** **view** `integer (min 0)` Profile views per day. **connect** `integer (min 0)` Connection requests per day. **message** `integer (min 0)` LinkedIn messages per day. **inmails** `integer (min 0)` InMails per day. **profileEngagement** `integer (min 0)` ENGAGEMENT actions per day — post likes, comments and skill endorsements. **email** `integer (min 0)` Emails per day sent through campaigns using this account. **follow** `integer (min 0)` Profile follows per day. **isPaused** `boolean` Pause every campaign running on this account. **warmup** `boolean` Ramp volumes up gradually instead of starting at full limits. **birthday** `boolean` Auto-congratulate connections on their birthday. **birthdayContent** `string` Message sent on a connection's birthday. **anniversary** `boolean` Auto-congratulate connections on a work anniversary. **anniversaryContent** `string` Message sent on a work anniversary. **role** `boolean` Auto-congratulate on job changes. **roleContent** `string` Message sent when a connection changes job. # AI agents Source: https://docs.linkedcamp.com/mcp/tools/agents Agents that reply to prospects, draft content, and book meetings, plus the knowledge base they draw on. > [!NOTE] > > Requires the **Agents** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`agent_delete`](#agent_delete) | Write, Destructive | | [`agent_duplicate`](#agent_duplicate) | Write | | [`agent_get`](#agent_get) | Read-only | | [`agent_list`](#agent_list) | Read-only | | [`agent_logs`](#agent_logs) | Read-only | | [`agent_query`](#agent_query) | Read-only | | [`agent_stats`](#agent_stats) | Read-only | | [`agent_train`](#agent_train) | Write | | [`agent_upsert`](#agent_upsert) | Write, Destructive | | [`kb_attach`](#kb_attach) | Write | | [`kb_delete`](#kb_delete) | Write, Destructive | | [`kb_list`](#kb_list) | Read-only | | [`kb_upsert`](#kb_upsert) | Write, Destructive | ## agent\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Delete an agent. Campaigns and conversations pointing at it lose their automated replies, silently — prospects mid-conversation simply stop getting answers. Irreversible, and its knowledge attachments and training go with it. Read `agent_list` for which campaigns use it, show the user, and get an explicit yes first. To stop an agent replying without destroying it, use `agent_upsert` with `isActive: false`, or `conversation_update` with `assistant: false` for one thread. Requires the "Agents" permission on the plan. ### Parameters **agentId** `string` *required* AI agent id, from `agent_list`. ## agent\_duplicate Write Copy an agent, optionally into a sub-account. Copies the configuration; the duplicate still needs `agent_train` before its knowledge works. Passing `userId` to place it in another user's account is accepted only from an account owner. Requires the "Agents" permission on the plan. ### Parameters **agentId** `string` *required* AI agent id, from `agent_list`. **userId** `string` Sub-account owner id. Omit to act on your own data. ## agent\_get Read-only One agent's full configuration: personality, intent, instructions, FAQs, follow-ups and booking action. Read this out to the user when they are choosing an existing agent. Configuration only: for what it actually said use `agent_logs`, for how it would answer a specific question `agent_query`, and for volumes `agent_stats`. Requires the "Agents" permission on the plan. ### Parameters **agentId** `string` *required* AI agent id, from `agent_list`. ## agent\_list Read-only AI agents configured for this account. CHAT agents reply to prospects in the inbox, CONTENT agents draft LinkedIn posts, and the rest are specialised assistants. Start here when the user asks about automated replies, and show them `agent_get` so they can judge the fit before anything is attached. An agent writes replies; a persona (`persona_list`) decides who qualifies; a knowledge base (`kb_list`) is the material an agent draws on. Attaching one to a campaign is `campaign_update` — and it answers real prospects by itself, so never attach one unasked. Requires the "Agents" permission on the plan. ### Parameters **type** `CHAT | VOICE | CONTENT | CAMPAIGN | REPORTING` Filter by type. **keyword** `string` Free-text search. **withStats** `boolean` (default: false) Include conversation and booking counts. ## agent\_logs Read-only What an agent was asked and what it answered — the trace to read when its replies look wrong. What it actually said in real conversations. To try a hypothetical instead, without sending anything, use `agent_query`; to read the prospect-facing thread use `conversation_get`. Requires the "Agents" permission on the plan. ### Parameters **agentId** `string` *required* AI agent id, from `agent_list`. **page** `integer (min 1)` (default: 1) 1-indexed page number. ## agent\_query Read-only Run a question through an agent against a real conversation, to see how it would answer. Returns the answer without sending anything — nothing reaches the prospect, which makes this the safe way to vet an agent before it goes active. For what it has already said use `agent_logs`. This is not a way to reply to anyone: sending an inbox message has no tool at all. Requires the "Agents" permission on the plan. ### Parameters **agentId** `string` *required* AI agent id, from `agent_list`. **conversationId** `string` *required* Context for the retrieval. **query** `string` *required* The question to put to the agent. ## agent\_stats Read-only Conversations handled, replies sent and appointments booked, across all agents. Totals across every agent, not one — there is no per-agent breakdown here. To judge a single agent's quality read `agent_logs`. Requires the "Agents" permission on the plan. *No parameters.* ## agent\_train Write Rebuild the agent's knowledge embeddings from its attached knowledge-base entries. Required after every `kb_upsert` or `kb_attach`, or the agent answers from stale material — this is the step most easily forgotten. It only re-indexes existing knowledge: it does not change the agent's instructions (`agent_upsert`) and does not teach it anything not attached via `kb_attach`. Requires the "Agents" permission on the plan. ### Parameters **agentId** `string` *required* AI agent id, from `agent_list`. ## agent\_upsert WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Create an AI agent, or update one by passing `agentId`. A CHAT agent will reply to real prospects once it is active and attached to a campaign — set `isActive: false` while iterating on its instructions. The behaviour comes from `personality` (who it is), `intent` (what it is trying to achieve) and `instructions` (how it should write). This creates or edits the agent and nothing else. It does not attach it to a campaign (`campaign_update`), give it source material (`kb_upsert` then `kb_attach`), or build its embeddings (`agent_train`, which must run after any knowledge change). Test with `agent_query` before it touches a real conversation. There is no tool to delete an agent. Requires the "Agents" permission on the plan. ### Parameters **agentId** `string` Omit to create a new agent. **name** `string` *required* Internal name. **type** `CHAT | VOICE | CONTENT | CAMPAIGN | REPORTING` CHAT for inbox replies, CONTENT for post drafting. **businessName** `string` Company the agent represents; injected into its prompt. **provider** `OPENAI | ANTHROPIC | GEMINI | GROK | DEEPSEEK` Primary model provider. Must be connected. **fallbackProvider** `OPENAI | ANTHROPIC | GEMINI | GROK | DEEPSEEK` Used when the primary provider errors. **language** `string` Language code, e.g. "en", "fr", "de", "it", "pt", "ja". **channels** `string[]` Where the agent operates, e.g. \["linkedin","email"]. **personality** `string` Who the agent is and how it carries itself. **intent** `string` The outcome it is steering the conversation toward. **instructions** `string` Concrete writing rules: tone, length, what to avoid. **prompt** `string` Raw system prompt override. Usually leave unset. **topics** `string[]` Subjects the agent is allowed to discuss. **faqs** `object[]` Canned answers the agent should use verbatim. **properties** **question** `string` *required* A question leads ask. **answer** `string` *required* The answer the agent gives, verbatim. **followups** `array of object (free-form)` Follow-up messages sent when a lead goes quiet. **prohabitedWords** `string[]` Words the agent must never use. Field name is spelled this way in the schema. **waitTime** `integer (min 0)` Minutes to wait before replying, so it reads as human. **maxMessages** `integer (min 1)` Cap on agent messages per conversation. **pauseBotOnManualMessage** `boolean` Stand down as soon as a human replies in the thread. **stopScenarios** `object` Situations in which the agent stops replying. **properties** **aggressive** `boolean` Stop when the lead becomes hostile. **goodbye** `boolean` Stop when the lead signs off. **notInterested** `boolean` Stop when the lead declines. **action** `"APPOINTMENT"` Enable calendar booking. **actionSettings** `object` Booking settings. Used when `action` is "APPOINTMENT". **properties** **calendar** `string` Which calendar to book into: a Calendly event, a GoHighLevel calendar id, or "CUSTOM" to share `customCalendarLink`. **calendarType** `string` e.g. "calendly", "ghl". **customCalendarLink** `string` Booking page URL the agent shares. Required when `calendar` is "CUSTOM", which also forces `sendLinkOnly`. **sendLinkOnly** `boolean` Send the booking link instead of negotiating a time. **pauseBotOnBooking** `boolean` Stop replying to a lead once they have booked. **userIds** `string[]` Share this agent with these sub-accounts. **notify** `boolean` Notify you when the agent replies. **isActive** `boolean` Whether the agent runs. Keep false while drafting. ## kb\_attach Write Include or exclude a knowledge entry for one agent. Run `agent_train` afterwards or the change has no effect on answers. Scoped to one agent: it neither creates the entry (`kb_upsert`) nor deletes it, and there is no tool to delete a knowledge entry. Requires the "Agents" permission on the plan. ### Parameters **agentId** `string` *required* AI agent id, from `agent_list`. **kbId** `string` *required* Knowledge-base entry id, from `kb_list`. **value** `boolean` (default: true) true attaches, false detaches. ## kb\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Remove a knowledge entry and its embeddings. The source material is gone — a crawled page would have to be crawled again, pasted text retyped — so confirm with the user first; `kb_list` shows what is there. The agent keeps answering, just without this material, and it will still cite it until `agent_train` reruns. To stop one agent using an entry while keeping it, use `kb_attach` to exclude it instead of deleting. Requires the "Agents" permission on the plan. ### Parameters **agentId** `string` *required* AI agent id, from `agent_list`. **kbId** `string` *required* Knowledge-base entry id, from `kb_list`. ## kb\_list Read-only Source material agents can draw on: crawled URLs, uploaded files and pasted text. Account-wide. Which agent may use which entry is set per agent by `kb_attach`, so an entry listed here is not necessarily in use. Requires the "Agents" permission on the plan. *No parameters.* ## kb\_upsert WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Add source material for agents. Type URL crawls a page, TEXT stores pasted content. Three steps, and skipping either of the last two leaves the agent unchanged: add it here, attach it with `kb_attach`, then rebuild with `agent_train`. Storing material does not change how the agent writes — that is `agent_upsert` instructions. Requires the "Agents" permission on the plan. ### Parameters **\_id** `string` Omit to create a new entry. **type** `URL | FILE | TEXT` *required* Filter by type. **title** `string` Short label. **url** `string` Required when type is URL. **content** `string` Required when type is TEXT. # Analytics Source: https://docs.linkedcamp.com/mcp/tools/analytics Performance, at campaign, sending-account and whole-account level. > [!NOTE] > > Requires the **Reporting** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`analytics_account`](#analytics_account) | Read-only | | [`analytics_campaign`](#analytics_campaign) | Read-only | | [`analytics_campaign_funnel`](#analytics_campaign_funnel) | Read-only | | [`analytics_reporting`](#analytics_reporting) | Read-only | | [`analytics_trend`](#analytics_trend) | Read-only | ## analytics\_account Read-only Roll-up across every campaign in your account: totals by action type, reply sentiment breakdown, and tag distribution. SLOW — it aggregates every campaign and every lead. On a large account it may not complete at all. Prefer `analytics_reporting` for a time series or `analytics_campaign` for one campaign; reach for this only when a true account-wide roll-up is needed, and narrow it with `range`. ### Parameters **status** `string` Restrict to campaigns in this status. **tagId** `string` Restrict to leads carrying this tag. **range** `object` Date window as \{ from, to } — epoch milliseconds or ISO 8601. Omit for the backend default. **properties** **from** `string | number` Start of the window. **to** `string | number` End of the window. **startDate** `string | number` Alias for `from`. **endDate** `string | number` Alias for `to`. ## analytics\_campaign Read-only Headline performance for one campaign: prospects found, invites sent and accepted, messages, InMails, emails sent/opened/clicked/bounced, and replies. Omit `campaignId` for a roll-up across your whole account. Start here for "how is this campaign doing" — it is the cheap one. Totals only: for a day-by-day series use `analytics_reporting`, for where people drop out use `sequence_step_stats`, and for a spreadsheet use `campaign_export_stats`. ### Parameters **campaignId** `string` Campaign id, from `campaign_list` or `campaign_create`. **userId** `string` Sub-account owner id. **range** `object` Date window as \{ from, to } — epoch milliseconds or ISO 8601. Omit for the backend default. **properties** **from** `string | number` Start of the window. **to** `string | number` End of the window. **startDate** `string | number` Alias for `from`. **endDate** `string | number` Alias for `to`. **includeGraph** `boolean` (default: false) Also return the day-by-day series for charting. ## analytics\_campaign\_funnel Read-only Stage-by-stage conversion for one campaign over a window — the numbers behind "where are we losing people". SLOW on a campaign with many leads: it walks every activity row and may not complete at all. Use `sequence_step_stats` for a fast per-step breakdown — it answers the same question on a large campaign. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **range** `object` Date window as \{ from, to } — epoch milliseconds or ISO 8601. Omit for the backend default. **properties** **from** `string | number` Start of the window. **to** `string | number` End of the window. **startDate** `string | number` Alias for `from`. **endDate** `string | number` Alias for `to`. ## analytics\_reporting Read-only Parallel daily series — engagements, invites, messages, InMails, follows, event invites, opportunities, emails sent/opened/clicked/bounced, accepted, replied — aligned to a shared `dates` array. The right tool for "how did we trend over the last 30 days". A series per day, not a total: for one campaign's totals use `analytics_campaign`, and for months rather than days use `analytics_trend`. Note it scopes by LinkedIn account, not by campaign. ### Parameters **linkedAccountId** `string` Narrow to one LinkedIn account. **userId** `string` Sub-account owner id. Omit to act on your own data. **range** `object` Date window as \{ from, to } — epoch milliseconds or ISO 8601. Omit for the backend default. **properties** **from** `string | number` Start of the window. **to** `string | number` End of the window. **startDate** `string | number` Alias for `from`. **endDate** `string | number` Alias for `to`. **filter** `string[]` Restrict to specific series names, e.g. \["invites","accepted","replied"]. ## analytics\_trend Read-only Month-over-month totals for one action type, optionally scoped to a campaign or LinkedIn account. One action type per call and one point per month — the long view. For daily granularity across all action types at once use `analytics_reporting`. ### Parameters **months** `integer (1–24)` (default: 6) How many months back to include. **type** `string` Action type, e.g. "CONNECT", "MESSAGE", "EMAIL". **campaignId** `string` Campaign id, from `campaign_list` or `campaign_create`. **linkedAccountId** `string` LinkedIn account id, from `linkedin_account_list`. # Automations Source: https://docs.linkedcamp.com/mcp/tools/automation Account-wide, event-driven workflows. Distinct from a campaign flow: an automation reacts to something happening (a reply, a tag, a booking) rather than walking a lead through a sequence. > [!NOTE] > > Requires the **Automations** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`automation_duplicate`](#automation_duplicate) | Write | | [`automation_get`](#automation_get) | Read-only | | [`automation_list`](#automation_list) | Read-only | | [`automation_upsert`](#automation_upsert) | Write | ## automation\_duplicate Write Copy an automation into a new inactive draft. The copy starts inactive, so it is safe: nothing runs until `automation_upsert` sets `isActive: true`. Use it to try a change without touching the automation currently handling live events. ### Parameters **automationId** `string` *required* Automation id, from `automation_list`. ## automation\_get Read-only One automation with its full workflow graph. Read one before authoring another with `automation_upsert`: the node and edge shape is not documented anywhere else, and a hand-built graph that does not match it will not run. ### Parameters **automationId** `string` *required* Automation id, from `automation_list`. ## automation\_list Read-only Account automations — event-driven workflows that run outside any single campaign. This is also where event delivery to your own systems belongs: The MCP server has no webhook tools. Manage REST webhooks through the [Webhooks API](/api-reference/webhooks/create-webhook). A campaign sequence is a different thing entirely — that is `flow_get` and `flow_set`. *No parameters.* ## automation\_upsert Write Create an automation, or update one by passing `_id`. The `flow` graph uses the same node/edge shape as the automations builder in the web app — read an existing one with `automation_get` before authoring a new graph by hand. Setting `isActive: true` makes it run against live events, which can message real people — leave it false while drafting and get an explicit yes before activating. It replaces the whole `flow` graph rather than patching it, so pass the complete graph. It does not touch any campaign sequence (`flow_set`). There is no tool to delete an automation. ### Parameters **\_id** `string` Omit to create a new automation. **title** `string` *required* Short label. **description** `string` *required* Longer explanatory text. **flow** `object (free-form)` Workflow graph — nodes and edges. **isActive** `boolean` Whether it runs. Keep false while drafting. # Campaigns Source: https://docs.linkedcamp.com/mcp/tools/campaigns The campaign lifecycle: create, configure, source prospects, launch, and manage once live. > [!NOTE] > > Requires the **Campaigns** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`campaign_activity_summary`](#campaign_activity_summary) | Read-only | | [`campaign_add_prospects`](#campaign_add_prospects) | Write, Destructive | | [`campaign_create`](#campaign_create) | Write | | [`campaign_create_ab_variant`](#campaign_create_ab_variant) | Write | | [`campaign_delete`](#campaign_delete) | Write, Destructive | | [`campaign_duplicate`](#campaign_duplicate) | Write | | [`campaign_export_stats`](#campaign_export_stats) | Write | | [`campaign_generate_ai_sequence`](#campaign_generate_ai_sequence) | Write | | [`campaign_get`](#campaign_get) | Read-only | | [`campaign_launch`](#campaign_launch) | Write, Destructive | | [`campaign_list`](#campaign_list) | Read-only | | [`campaign_logs`](#campaign_logs) | Read-only | | [`campaign_preview_message`](#campaign_preview_message) | Read-only | | [`campaign_send_test_email`](#campaign_send_test_email) | Write, Destructive | | [`campaign_set_source`](#campaign_set_source) | Write, Destructive | | [`campaign_set_status`](#campaign_set_status) | Write | | [`campaign_update`](#campaign_update) | Write | | [`campaign_upload_leads`](#campaign_upload_leads) | Write | | [`search_url_build`](#search_url_build) | Read-only | ## campaign\_activity\_summary Read-only Aggregate counts of pending, completed and failed actions across the campaign. Three numbers for the whole campaign — the cheapest "is it working" check. For the same split per step use `sequence_step_stats`, and for the leads behind one step `sequence_leads_at_step`. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. ## campaign\_add\_prospects WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Top up an already-running campaign with prospects from a new source, without touching its sequence or existing leads. Runs in the background and can take several minutes. Two hard preconditions, both enforced by the backend as thrown errors: the campaign must be ACTIVE — a DRAFTED one fails with "Campaign is not active!" — and it must have finished filtering its first batch. So this is never how a new campaign gets its audience: for that use `campaign_set_source` (a search URL) or `campaign_upload_leads` (CSV rows) before launching. It also does not add leads to this campaign directly — the backend creates a child campaign pointing at this one, which is why `campaign_delete` reports removing active children. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **type** `enum (9 values)` *required* Source kind for the new batch. **url** `string` LinkedIn source URL, for non-CRM types. **field** `string` CRM sources: contact property holding the profile URL. **query** `string` CRM sources: segment / list query. ## campaign\_create Write Create a DRAFTED campaign. Nothing sends until `campaign_launch`. Pass `sourceUrl` to set the prospect source at the same time (a LinkedIn or Sales Navigator search URL, a group, an event, or a post). For a CSV-driven campaign, omit `sourceUrl` and follow up with `campaign_upload_leads`. This is the right starting point for EVERY new campaign. Never begin one with `campaign_duplicate` unless the user named a campaign to copy — see that tool for why. It creates the campaign and nothing else: the sequence comes from `flow_set`, accounts and limits from `campaign_update`, and it only sends after `campaign_launch`. ### Parameters **title** `string` *required* Campaign name, shown throughout the app. **sourceUrl** `string` LinkedIn search / Sales Navigator / Recruiter / group / event / post URL to harvest prospects from. The source type is inferred from the URL shape. ## campaign\_create\_ab\_variant Write Split a campaign into an A/B pair so two versions of the sequence run against comparable halves of the audience. Compare them later with `analytics_campaign`. This SPLITS, it does not copy: the backend moves half of the not-yet-contacted leads out of the original into a new DRAFTED campaign, copies the flow, and renames the original to "\ \[A]". The original therefore ends up with half the audience it had. It needs more than 10 leads still waiting to be contacted and refuses otherwise with "Not enough leads to do AB testing, Duplicate campaign instead!" — in which case `campaign_duplicate` is the backend's own suggestion. Use `campaign_duplicate` when the audience should be left alone, and this when the point is to compare two versions on one audience. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. ## campaign\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Remove a campaign from your account by moving it to DELETED. Nothing is erased — the campaign, its leads, sequences and activity records all stay in the database, and the campaign simply stops appearing in listings. There is no tool to bring it back, so confirm with the user first. Sending stops because the workers only pick up ACTIVE campaigns; to stop sending without removing the campaign, that is a pause, which belongs in the web app. The only tool allowed to write a campaign status, and the only value it writes is DELETED — `campaign_update` has no status parameter and nothing sets ACTIVE, PAUSED or ARCHIVED. Deleted campaigns vanish from `campaign_list`, so confirm before calling: there is no undelete. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. ## campaign\_duplicate Write Copy one specific existing campaign — its settings and its whole sequence — into a new DRAFTED campaign, without copying the leads. Use this ONLY when the user asks to duplicate a campaign they have named. It is not a way to start a new campaign: a new campaign has nothing to duplicate, and the copied sequence carries the original audience's messaging. To start fresh, use `campaign_create`. The copied steps cannot be rewritten from here either — `sequence_update` edits are reverted at launch on a campaign that has not launched yet, so a duplicate is only useful when the existing copy is meant to be kept. ### Parameters **campaignId** `string` *required* The existing campaign the user named. Never guess this — get it from `campaign_list`. ## campaign\_export\_stats Write Generate a CSV export of campaign performance. Returns a filename; the file is served from the CDN and also emailed to the account owner — so it leaves the conversation, which is worth mentioning before calling it. Performance numbers, not people: for a file of prospects use `lead_export`, and to read the numbers here instead use `analytics_campaign`. ### Parameters **campaignId** `string` Campaign id, from `campaign_list` or `campaign_create`. **range** `object` Date window as \{ from, to } — epoch milliseconds or ISO 8601. Omit for the backend default. **properties** **from** `string | number` Start of the window. **to** `string | number` End of the window. **startDate** `string | number` Alias for `from`. **endDate** `string | number` Alias for `to`. ## campaign\_generate\_ai\_sequence Write Ask the platform's own AI to draft a whole campaign — copy and multi-step sequence — from a brief, and create it as a draft. Requires an AI provider connected in the web app under Settings - Integrations. Use this when the user wants the platform to write the sequence for them; to author one yourself, use `flow_set`. ### Parameters **title** `string` *required* Campaign name. **goal** `string` *required* What the campaign should achieve, e.g. "book discovery calls". **targetPersona** `string` *required* Who is being targeted, e.g. "Heads of RevOps at Series B SaaS". **industry** `string` *required* Industry. **productDescription** `string` *required* What you are offering, in a sentence or two. **tone** `string` *required* Voice of the copy, e.g. "friendly", "direct", "consultative". **keyPoints** `string` *required* Proof points or hooks the copy should work in. **stepCount** `integer (1–10)` *required* How many steps the sequence should have. **country** `string` Country. ## campaign\_get Read-only Everything about one campaign: settings, schedule, limits, attached accounts, lead source, live counters and the flow outline. This is the tool to call before changing anything — it also reports what is still missing before the campaign can launch, in `_readiness.blockers`, which must be empty before `campaign_launch`. Read `status` here before choosing how to edit copy: `flow_set` for a DRAFTED campaign, `sequence_update` only once it is ACTIVE or PAUSED. A settings-and-counters snapshot: for the sequence in detail use `flow_get`, for performance `analytics_campaign`, and for the people `lead_list`. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **includeFlow** `boolean` (default: true) Include a readable outline of the campaign sequence. ## campaign\_launch WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Start a campaign. THIS BEGINS SENDING REAL OUTREACH to real people from the connected LinkedIn account and mailboxes — invitations, messages and emails go out on the configured schedule. Run `campaign_get` first and clear every blocker: a saved flow, a lead source, a sending account, and (for CSV campaigns) a finished import. Show the user the full sequence and the audience and get an explicit yes in the conversation before calling — not an assumed one. Launch rebuilds every step from the saved flow graph, so any `sequence_update` edit made while the campaign was a draft is overwritten here; fix a draft's copy with `flow_set` instead. This is the only tool that starts a campaign. Pausing or resuming one afterwards has no tool at all and happens in the web app. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **skipPreflight** `boolean` (default: false) Skip the local readiness check and let the backend decide. Only useful if the check is wrong. ## campaign\_list Read-only Campaigns in your account, newest first, 20 per page. Use `status` to filter — DRAFTED campaigns are the ones still being built, ACTIVE ones are sending right now. DELETED campaigns never appear here, which is why a deletion looks like a disappearance. The list view, a few fields each: for one campaign in full use `campaign_get`, and for performance `analytics_campaign`. Passing `userId` to read a sub-account's campaigns is accepted only from an account owner. ### Parameters **status** `ACTIVE | PAUSED | FAILED | DELETED | COMPLETED | ARCHIVED | DRAFTED` Filter by lifecycle status. **keyword** `string` Search campaign titles. **page** `integer (min 1)` (default: 1) 1-indexed page number. **userId** `string` Sub-account owner id. Omit for your own campaigns. ## campaign\_logs Read-only Chronological record of everything that happened to a campaign: created, started, paused, resumed, lead sources added, settings changed, limits hit. Changes to the CAMPAIGN, written by whoever made them — the audit trail to read when a user asks why a campaign stopped or who changed a limit. Not what happened to the prospects: that is `activity_list`, `lead_get` or `sequence_step_stats`. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. ## campaign\_preview\_message Read-only Render a draft message against a real lead from the campaign so you can see how the merge fields resolve before committing the copy to a step. Nothing is sent and nothing is saved — this is the safe way to check a \{\{placeholder}} actually resolves, since an unknown one renders empty rather than failing. Save the copy with `flow_set`; to put a real email in front of yourself instead, `campaign_send_test_email`. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **message** `string` *required* Draft copy, including \{\{firstName}}-style placeholders. ## campaign\_send\_test\_email WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Send one real email to an address you control, using a campaign mailbox, so you can check rendering and deliverability before launch. This does send mail: show the user the recipient, subject and body and get an explicit yes first. Only ever to an address they control — it is not a way to message a prospect, and there is no tool for that. To check merge fields without sending anything, use `campaign_preview_message`. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **emailAccountId** `string` *required* Mailbox to send from. See `email_account_list`. **email** `string (email)` *required* Where to send the test. Use your own address. **content** `string` *required* Email body. **subject** `string` Subject line. **emailAsText** `boolean` Send as plain text rather than HTML. ## campaign\_set\_source WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Point a DRAFTED campaign at where its prospects come from: a LinkedIn/Sales Navigator search URL, a group, an event, a post, or a CRM segment. For an ACTIVE campaign use `campaign_add_prospects` instead — that adds to the existing pool rather than replacing the source. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **url** `string` A LinkedIn LIST url — a basic search, a Sales Navigator (`/sales/`) search, a Recruiter (`/talent/`) search, or a group / event / post. Not a single profile. Required unless using a CRM source. **surface** `sales-navigator | recruiter | basic` Assert which LinkedIn surface the url belongs to. The call is rejected if the url does not match, the same way the web app validates its Sales Navigator and Recruiter tabs. Omit to detect it. **type** `enum (9 values)` Override the inferred source type. Use "hubspot" or "ghl" for CRM pulls. **field** `string` CRM sources: the contact property holding the LinkedIn profile URL. **query** `string` CRM sources: the segment / list / filter query to pull. ## campaign\_set\_status Write Pause a running campaign, or resume one that is paused. PAUSED halts sending immediately; pending steps stay queued and pick up where they left off when it resumes. ACTIVE starts real outreach again, so ASK THE USER before resuming — the campaign may have been paused for a reason they know and you do not. Nothing is destroyed either way, so your client will not prompt for you: the confirmation has to be one you asked for. Pausing needs no ceremony — it only stops sending, and is undone by resuming. Deliberately narrower than the `status` field it writes. It will not ARCHIVE or COMPLETE a campaign — those are web-app housekeeping — and it will not DELETE one, which is `campaign_delete`. It also refuses to resume anything that is not already PAUSED: `updateCampaign` writes the field blindly, so setting ACTIVE on a DRAFTED campaign would mark it live without a lead source, a saved flow, a sending account or materialised sequences, none of which this path checks. A campaign that has never run is started with `campaign_launch`, which validates all of that first. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **status** `PAUSED | ACTIVE` *required* PAUSED halts sending. ACTIVE resumes a paused campaign, and is refused for any other current status. ## campaign\_update Write Change a campaign's SETTINGS: title, sending accounts, schedule, daily limits, timezone and every safety toggle. Only the fields you pass are changed. Attaching accounts is done here: one `linkedAccountId` for LinkedIn steps, and `emailAccountIds` — a list — for EMAIL steps. Ask the user which accounts when there is a choice. NOT this tool: campaign status. It cannot start, pause, resume, archive or delete a campaign, and there is no `status` parameter. To start one use `campaign_launch`; to remove one use `campaign_delete`. Pausing, resuming and archiving are web-app only and have no tool at all — say so rather than looking for a substitute. Nor does it touch the sequence (`flow_set`) or the audience (`campaign_set_source`). One side effect worth knowing: changing `linkedAccountId` rewrites that account onto every lead already in the campaign, not just future ones. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **title** `string` Short label. **linkedAccountId** `string` The ONE LinkedIn account this campaign sends from. Required for any LinkedIn step. A campaign cannot use two. If `linkedin_account_list` returns more than one, ask the user which — do not pick for them. **emailAccountIds** `string[]` Mailboxes for EMAIL steps. Unlike the LinkedIn account, several are allowed and sends rotate across them. Only attach these if the user wants email steps, and ask which mailboxes. **timezone** `string` IANA timezone, e.g. "America/New\_York". Governs the schedule. **schedule** `object` Sending window per weekday, keyed 0 (Sunday) to 6 (Saturday), in the campaign timezone. **properties** **0** `object` Sunday **1** `object` Monday **2** `object` Tuesday **3** `object` Wednesday **4** `object` Thursday **5** `object` Friday **6** `object` Saturday **campaginLimits** `object` Per-day caps per step type. Note the field spelling. **properties** **CONNECT** `integer (min 0)` Connection invites per day. **MESSAGE** `integer (min 0)` LinkedIn messages per day. **INMAILS** `integer (min 0)` InMails per day. **ENGAGEMENT** `integer (min 0)` Profile engagements per day. **FOLLOW** `integer (min 0)` Follows per day. **tags** `string[]` Tag ids applied to every lead in this campaign — this identifies the campaign's leads, so it should be a tag belonging to THIS campaign. Never reuse another campaign's tag: the two campaigns' leads then become indistinguishable. Mint one with `tag_create` (short label, interest NEUTRAL) and pass its id. Pass \[] to remove all tags. **assignTo** `object (free-form)` Assign leads to team members. Shape mirrors the web app. **leadsPriority** `string` Ordering strategy for working the lead queue, e.g. "newest" / "oldest". **stopOnReply** `boolean` Halt a lead's sequence as soon as they reply. Default true. **skipProfiles** `boolean` Skip prospects you already have an open conversation with. **uniqueProfiles** `boolean` Never enrol the same profile in two campaigns. Default true. **premiumProfiles** `boolean` Only target LinkedIn Premium / Open Profile members. **connectionOutreach** `boolean` Target existing 1st-degree connections instead of new ones. **snOutreach** `boolean` Use Sales Navigator messaging. Requires a Premium LinkedIn account. **prioritizeNewLeads** `boolean` Work newly-found prospects before older ones. **reload** `boolean` Re-run the search periodically to pull in newly matching prospects. **trackOpens** `boolean` EMAIL steps: insert an open-tracking pixel. **trackClicks** `boolean` EMAIL steps: rewrite links for click tracking. **emailAsText** `boolean` Send email as plain text. Better deliverability, no tracking. **pauseCampaign** `boolean` Pause the campaign without changing its status. **scheduledAt** `string | number` Future timestamp to auto-start the campaign, instead of launching it now with `campaign_launch`. **agentId** `string` AI agent that answers replies in this campaign's inbox. Pass null to detach it. Never set this on your own: an agent writes to real prospects without further approval. Ask the user whether they want one, and offer both routes — pick an existing agent from `agent_list`, or build one with `agent_upsert`, give it material with `kb_upsert` and `kb_attach`, then `agent_train`. A campaign with no agent is perfectly normal; replies just come to the inbox. ## campaign\_upload\_leads Write Bulk-load prospects into a campaign from parsed CSV rows. `header` maps each column name to a platform field — profileUrl, salesNavUrl, recruiterUrl, email, firstName, lastName, fullName, personalization, phone, website, or "customVariable" to keep it as a merge field. Rows with neither a profile URL nor an email are skipped silently. Import runs asynchronously; the campaign is only launchable once `isFiltered` flips true. Use this when the user has a list in hand. When they describe an audience instead, the audience is a LinkedIn search and belongs in `campaign_set_source` — build the URL with `search_url_build`. For a campaign that is already running, neither applies: that is `campaign_add_prospects`. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **header** `object (free-form)` *required* \{ "CSV Column Name": "targetField" }. Use "customVariable" for anything you want as a merge field. **leads** `array of object (free-form)` *required* Row objects keyed by the CSV column names used in `header`. **removeDuplicates** `boolean` (default: true) Skip prospects already enrolled in another active or paused campaign on this account. ## search\_url\_build Read-only Turn an audience description into a LinkedIn or Sales Navigator people-search URL, so a campaign source can be described rather than pasted. Returns the url plus what it managed to express — hand it to `campaign_set_source`. What it can build: job titles (included and excluded) and free-text keywords with boolean operators. What it CANNOT build: geography, industry, company size, seniority and years-in-role. Sales Navigator only accepts those as numeric ids from its own typeahead (`id:103644278` is United States), they cannot be derived from a name, and a wrong id silently searches the wrong audience. For those, either ask the user to paste a Sales Navigator URL with the filters already set, or pass the ids through `extraFilters` if the user supplies them. Never guess one. Recruiter (`/talent/`) URLs cannot be built at all — ask the user for one. ### Parameters **surface** `basic | sales-navigator` *required* "basic" is ordinary LinkedIn search; "sales-navigator" needs a Sales Navigator seat. **keywords** `string` Free text. Supports boolean operators, e.g. '"chatbot" OR "AI agent"'. **titles** `string[]` Job titles to include, as plain text. **excludeTitles** `string[]` Job titles to exclude. Sales Navigator only — basic search cannot express an exclusion. **company** `string` Basic search only: current company, free text. **school** `string` Basic search only: school, free text. **firstName** `string` Basic search only. **lastName** `string` Basic search only. **extraFilters** `object[]` Id-based filters, only when the USER supplied the ids or they came from a URL they pasted. Do not populate this from memory. **properties** **type** `string` *required* Sales Navigator filter type, e.g. REGION, INDUSTRY, COMPANY\_HEADCOUNT. **values** `object[]` *required* Values for this filter, each with the id LinkedIn assigns it. # Content Source: https://docs.linkedcamp.com/mcp/tools/content LinkedIn posts: drafting, scheduling and the recurring publishing calendar. > [!NOTE] > > Requires the **Publish** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`post_generate`](#post_generate) | Read-only | | [`post_list`](#post_list) | Read-only | | [`post_schedule_get`](#post_schedule_get) | Read-only | | [`post_schedule_set`](#post_schedule_set) | Write, Destructive | | [`post_schedule_settings`](#post_schedule_settings) | Write | | [`post_upsert`](#post_upsert) | Write, Destructive | ## post\_generate Read-only Generate LinkedIn post copy from a prompt using a connected AI provider. Returns text only and stores nothing — save it with `post_upsert`, or the copy is lost when the conversation moves on. Requires an AI provider connected in the web app under Settings - Integrations. Requires the "Publish" permission on the plan. ### Parameters **provider** `OPENAI | ANTHROPIC | GEMINI | GROK | DEEPSEEK` *required* Which connected AI provider to use. Providers are connected in the web app. **prompt** `string` *required* What the post should be about, and in what voice. ## post\_list Read-only Posts drafted, scheduled or published from a LinkedIn account, with their engagement numbers. Includes per-status counts. Posts published to the account's own feed — unrelated to campaign outreach, which is `campaign_list` and `analytics_campaign`. Read this before `post_upsert` to avoid creating a near-duplicate of something already queued. Requires the "Publish" permission on the plan. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. **status** `PENDING | DRAFTED | PUBLISHED | REQUIRE_APPROVAL | APPROVED | REJECTED` Filter by status. ## post\_schedule\_get Read-only The recurring weekly slots at which queued posts are published for an account. The repeating timetable, not the queue: for the posts themselves use `post_list`. Change the slots with `post_schedule_set` and the timezone or approval rules with `post_schedule_settings`. Requires the "Publish" permission on the plan. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. ## post\_schedule\_set WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Define the publishing times for one weekday. Queued posts are released into these slots. One weekday per call, and it replaces that day's times rather than adding to them — read `post_schedule_get` first. It does not schedule any particular post; that is `post_upsert` with `scheduledAt`. Requires the "Publish" permission on the plan. ### Parameters **scheduleId** `string` Omit to create a new slot. **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. **day** `string` *required* Weekday, e.g. "monday". **times** `string[]` *required* Publish times as 24-hour "HH:MM", e.g. \["09:00","17:30"]. **timezone** `string` IANA timezone for these times. **agentId** `string` CONTENT agent that fills empty slots automatically. **approval** `boolean` Require human approval before an auto-generated post publishes. **isActive** `boolean` Whether this is live. Keep false while drafting. ## post\_schedule\_settings Write Set the timezone, the auto-drafting CONTENT agent, and whether posts need approval before publishing. Account-wide publishing policy, not times — the times are `post_schedule_set`. Attaching a CONTENT agent here lets it draft posts on its own, so confirm with the user first; the agent is configured in `agent_upsert`. Requires the "Publish" permission on the plan. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. **agentId** `string` AI agent id, from `agent_list`. **timezone** `string` IANA timezone, e.g. "America/New\_York". **approval** `boolean` Require human approval before anything auto-generated goes out. ## post\_upsert WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Draft or schedule a LinkedIn post. `status: "DRAFTED"` keeps it private; `"PENDING"` with a `scheduledAt` queues it for publishing; `"REQUIRE_APPROVAL"` routes it to a reviewer. A PENDING post with a past or imminent `scheduledAt` will go live publicly — confirm the copy with the user first. This is the only tool that saves a post. `post_generate` writes copy but stores nothing, and `post_schedule_set` defines the weekly slots a PENDING post is released into, not this post's own time. Requires the "Publish" permission on the plan. ### Parameters **postId** `string` Omit to create a new post. **linkedAccountId** `string` *required* Account that will publish it. **content** `string` *required* Post body. **pinnedComment** `string` Comment auto-posted underneath, e.g. a link. **attachment** `object` Image, video or document to attach. **properties** **url** `string` *required* Publicly reachable URL of the image, video or document. **name** `string` File name, e.g. "launch-deck.pdf". Shown as the title of a document post. **type** `string` MIME type, e.g. "image/png", "video/mp4", "application/pdf". **scheduledAt** `string | number` When to publish, as epoch milliseconds or ISO 8601. **status** `PENDING | DRAFTED | PUBLISHED | REQUIRE_APPROVAL | APPROVED | REJECTED` DRAFTED keeps it private; PENDING queues it for publishing. # Core Source: https://docs.linkedcamp.com/mcp/tools/core Orientation. Call whoami once at the start of a conversation — the plan it reports decides whether Pro-only steps are usable at all, and permissions gates several features. Call reference before authoring a sequence or filtering by status; the vocabulary is not guessable. | Tool | Kind | | - | - | | [`reference`](#reference) | Read-only | | [`unread_counts`](#unread_counts) | Read-only | | [`whoami`](#whoami) | Read-only | ## reference Read-only The exact enum values, step-field requirements and defaults this API accepts. Read this before authoring a campaign flow or filtering by status — guessing a value produces a validation error, and the vocabulary is not guessable (e.g. campaign settings use the field name `campaginLimits`, spelled that way in the schema). A static vocabulary, not account data — it says which values exist, never which the account has. For the account's own tags, templates, personas or placeholders use `tag_list`, `template_list`, `persona_list` or `placeholder_list`. ### Parameters **topic** `all | sequence_steps | triggers | campaign | leads | placeholders | integrations | misc` (default: all) Narrow the reference to one area to keep the response small. ## unread\_counts Read-only Badge counts for notifications, unread conversations, pending activities and open tasks. Counts only, as a cheap way to see whether anything needs attention. For the items themselves use `notification_list`, `conversation_list`, `activity_list` or `task_list`. *No parameters.* ## whoami Read-only The authenticated account: name, email, role, plan, entitlements and notification settings. Call this first in a new conversation — the plan tells you whether Pro-only steps (Email, Qualifier, AI Hook, Finder, Event invite) are available, and `permissions` gates several features. For a team-member key this reports the account OWNER, not the team member: the backend resolves such a key to the owner, because that is the account being acted on and the one holding the plan. Identity and entitlements only. It reports no campaign or lead data, and it cannot change anything — profile edits are `account_settings_update`. Read `_derived` before proposing any Pro or permission-gated step, because the refusal from a gated tool is real and has no workaround. *No parameters.* # CRM and follow-up Source: https://docs.linkedcamp.com/mcp/tools/crm Connected CRMs, and the manual follow-up that happens around a conversation. Event delivery uses automations or REST webhooks. > [!NOTE] > > Requires the **Tasks** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`appointment_get`](#appointment_get) | Read-only | | [`appointment_list`](#appointment_list) | Read-only | | [`reminder_create`](#reminder_create) | Write | | [`reminder_delete`](#reminder_delete) | Write, Destructive | | [`reminder_list`](#reminder_list) | Read-only | | [`task_list`](#task_list) | Read-only | | [`task_upsert`](#task_upsert) | Write | ## appointment\_get Read-only Full detail for one booked meeting: time, timezone, status, and the lead and conversation it came out of. Read-only, like `appointment_list` — rescheduling and cancelling happen in the web app. ### Parameters **appointmentId** `string` *required* Appointment id, from `appointment_list`. ## appointment\_list Read-only Meetings booked out of conversations, or created in the web app. Read-only here by design: appointments are never inserted or edited by hand over this server, so there is no tool to create, change or cancel one. For the thread a meeting came out of use `conversation_get`. ### Parameters **leadId** `string` Lead id, from `lead_list`. **conversationId** `string` Conversation id, from `conversation_list`. **status** `CONFIRMED | CANCELLED | RESCHEDULED | NO_SHOW | COMPLETED` Filter by status. **page** `integer (min 1)` (default: 1) 1-indexed page number. ## reminder\_create Write Set a follow-up reminder on a lead or conversation. You are notified at `remindAt` — you, not the prospect; nothing is sent to them. It does not schedule a campaign step or delay one. To make a lead wait, use `lead_update` with `paused`. Cancel with `reminder_delete`. ### Parameters **title** `string` *required* Short label. **remindAt** `string | number` *required* When to fire, epoch milliseconds or ISO 8601. **description** `string` Longer explanatory text. **leadId** `string` Lead id, from `lead_list`. **conversationId** `string` Conversation id, from `conversation_list`. **linkedAccountId** `string` LinkedIn account id, from `linkedin_account_list`. ## reminder\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Cancel a reminder so it never fires. Does not affect the lead, the conversation, or any scheduled campaign step — only your own nudge goes away. One of the few deletions available here, and it destroys nothing a prospect sees. To close a to-do instead use `task_upsert` with `isCompleted`. ### Parameters **reminderId** `string` *required* Reminder id, from `reminder_list`. ## reminder\_list Read-only Follow-up reminders set on a conversation or a lead. Private nudges for your team at a point in time. They send nothing to the prospect and are unrelated to the campaign schedule, which is `campaign_update`. ### Parameters **conversationId** `string` Conversation id, from `conversation_list`. **leadId** `string` Lead id, from `lead_list`. ## task\_list Read-only Manual to-dos for your team, either across your whole account or for one lead. TASK steps in a campaign flow create these automatically. Work for a human, not sending steps: a pending campaign action is `activity_list` or `lead_flow_state`, and a dated nudge is `reminder_list`. Completing a task sends nothing. ### Parameters **leadId** `string` Only tasks attached to this lead. **linkedAccountId** `string` LinkedIn account id, from `linkedin_account_list`. **emailAccountId** `string` Mailbox id, from `email_account_list`. **page** `integer (min 1)` (default: 1) 1-indexed page number. ## task\_upsert Write Create a to-do, or update one by passing `taskId`. Set `isCompleted: true` to close it. An internal note-to-self with an owner; nothing is sent to the prospect and no campaign step is affected. For a timed personal nudge use `reminder_create`. ### Parameters **taskId** `string` Omit to create a new task. **title** `string` *required* What needs doing. **content** `string` Detail or context. **leadId** `string` Lead this relates to. **conversationId** `string` Conversation id, from `conversation_list`. **link** `string` Related URL. **tag** `string` Free-text label for grouping. **date** `string | number` Due date, epoch milliseconds or ISO 8601. **isCompleted** `boolean` Mark as done. # Flows and sequences Source: https://docs.linkedcamp.com/mcp/tools/flows Authoring the sequence a campaign runs, and inspecting how it is performing step by step. > [!NOTE] > > Requires the **Campaigns** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`flow_audit`](#flow_audit) | Read-only | | [`flow_from_template`](#flow_from_template) | Write | | [`flow_get`](#flow_get) | Read-only | | [`flow_history`](#flow_history) | Read-only | | [`flow_set`](#flow_set) | Write, Destructive | | [`sequence_leads_at_step`](#sequence_leads_at_step) | Read-only | | [`sequence_list`](#sequence_list) | Read-only | | [`sequence_step_stats`](#sequence_step_stats) | Read-only | | [`sequence_update`](#sequence_update) | Write, Destructive | ## flow\_audit Read-only What the most recent sequence edit actually did to the leads in flight: how many were re-pointed at a different step, how many were orphaned because their step no longer exists, and how many pending actions were cancelled or rescheduled. Call this straight after `flow_set` on an ACTIVE campaign — it is the only way to see the collateral damage of a rewrite, and orphaned leads stop progressing. It reports; it does not repair. Fixing an orphan means another `flow_set`, or `lead_move`. ### Parameters **flowId** `string` *required* From `flow_get`. ## flow\_from\_template Write Attach one of the platform's named sequence templates to a campaign and fill in its copy placeholders. Only works on a campaign that has no flow yet. The template decides which slots exist — supply whichever of longNote, shortNote, message1..3, subject1..3, content1..3 it uses. One of three ways to get a sequence, and the only one that reuses a prebuilt shape: `flow_set` writes an arbitrary sequence from a step list, and `campaign_generate_ai_sequence` has the platform draft one from a brief. List the available templates with `template_list` first — the name is matched against that library. To change the copy afterwards, call `flow_set`; this tool cannot be re-run on a campaign that already has a flow. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **sequence** `string` *required* Template name, matched against the shared template library. **content** `object` *required* Copy substituted into the template slots. **properties** **longNote** `string` Connection note (long form). **shortNote** `string` Connection note (short form). **message1** `string` LinkedIn message 1. **message2** `string` LinkedIn message 2. **message3** `string` LinkedIn message 3. **subject1** `string` Email / InMail subject 1, paired with content1. **subject2** `string` Email / InMail subject 2, paired with content2. **subject3** `string` Email / InMail subject 3, paired with content3. **content1** `string` Email / InMail body 1. **content2** `string` Email / InMail body 2. **content3** `string` Email / InMail body 3. ## flow\_get Read-only The saved sequence for a campaign, as both a readable outline and the raw React Flow graph. Node ids in the outline are the sequence ids you pass to `sequence_leads_at_step` and `sequence_step_stats`. Read-only. Read this before changing a sequence, then write with `flow_set` (any campaign) or `sequence_update` (copy only, and only once the campaign is ACTIVE or PAUSED). ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **includeRaw** `boolean` (default: false) Include the full nodes/edges arrays. Verbose — only needed to hand-edit the graph. ## flow\_history Read-only Every saved version of a campaign's sequence, each with the change audit: which steps were added, removed or edited, and how many leads that save moved or orphaned. The history of edits. Read it to explain how a sequence got into its current state — but it is not a way back: there is no tool to restore an old version, so a rollback means calling `flow_set` with the old steps. For the current sequence use `flow_get`, and for the effect of the latest save alone `flow_audit`. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **limit** `integer (1–50)` (default: 10) Most recent versions to return. ## flow\_set WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Replace a campaign's sequence with the steps you describe. This is how you write a campaign: give an ordered list of steps and the graph is compiled, validated and saved. Each step is one action — CONNECT, MESSAGE, EMAIL, INMAILS, ENGAGEMENT, FOLLOW, WITHDRAW, QUALIFIER, GPT, ASSIGN\_TAG, TASK … — with a `delay` measured from the previous step. A TRIGGER step branches on a condition (If\_Replied, If\_Connected, If\_Email\_Opened, …); it must be the last entry in its list, and the steps that follow go under `yes` or `no`. An omitted branch simply ends there. On a campaign that is already ACTIVE this is DESTRUCTIVE: leads are re-evaluated against the new graph, some are moved to different steps, and pending actions can be cancelled or rescheduled. `flow_audit` reports exactly what moved. On a DRAFTED campaign nothing is at stake. Call `reference` with topic "sequence\_steps" first if you are unsure which fields a step type needs. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **steps** `object[]` *required* The full sequence, in order. This replaces whatever is currently saved. **properties** **type** `enum (20 values)` *required* Step kind. LinkedIn: CONNECT, MESSAGE, INMAILS, VOICE, ENGAGEMENT, FOLLOW, FOLLOW\_COMPANY, EVENT, EVENT\_MESSAGE, GROUP\_MESSAGE, WITHDRAW. Email: EMAIL. Flow control: TRIGGER (branch), QUALIFIER (persona gate), ASSIGN\_TAG, SEND\_TO\_CAMPAIGN, TASK, API, GPT, FINDER. **delay** `integer (0–365)` How long to wait AFTER the previous step before running this one. Default 1 for actions, per-trigger default for TRIGGER. **delayType** `days | hours | minutes` Unit for `delay`. Default "days". **note** `string (≤300 chars)` CONNECT only: the invitation note (LinkedIn caps this at 300 characters, or 200 without Premium). **shortNote** `string (≤200 chars)` CONNECT only: fallback note used when the account has hit its long-note allowance. **subject** `string` EMAIL / INMAILS only: subject line. **message** `string` Body for MESSAGE, EMAIL, INMAILS, VOICE, GROUP\_MESSAGE, EVENT\_MESSAGE. Supports \{\{firstName}}-style merge fields. **connectWithoutMessage** `boolean` CONNECT only: send a bare invitation with no note. Higher accept rates, no personalisation. **useCredits** `boolean` INMAILS only: spend InMail credits when the lead is not Open Profile. **attachment** `object` File to attach to the message. Must already be hosted at a publicly reachable URL the platform can fetch. **abTestingEnabled** `boolean` Split traffic between the A copy above and the B copy below. **bNote** `string (≤300 chars)` Variant B invitation note. **bShortNote** `string (≤200 chars)` Variant B short-form invitation note. **bSubject** `string` Variant B subject. **bMessage** `string` Variant B body. **bConnectWithoutMessage** `boolean` Variant B sends a bare invitation with no note. **bAttachment** `object` File to attach to the message. Must already be hosted at a publicly reachable URL the platform can fetch. **postsToLike** `integer (0–10)` ENGAGEMENT: how many recent posts to like. **commentsToAdd** `integer (0–10)` ENGAGEMENT: how many posts to comment on. **skillsToEndorse** `integer (0–10)` ENGAGEMENT: how many skills to endorse. **followCompanyUrl** `string` FOLLOW\_COMPANY: the LinkedIn company page URL to follow. **eventUrl** `string` EVENT: the LinkedIn event URL to invite the lead to. **newCampaignId** `string` SEND\_TO\_CAMPAIGN: id of the campaign to move the lead into. **tagId** `string` ASSIGN\_TAG: id of the tag to apply (see `tag_list`). **tags** `string[]` Tag ids to apply when this step completes. **provider** `OPENAI | ANTHROPIC | GEMINI | GROK | DEEPSEEK` GPT step: which connected AI provider to call. **model** `string` GPT step: model id, e.g. "gpt-4o" or "claude-sonnet-4-5". **instructions** `string` GPT step: the prompt used to draft the personalised opener. **personaId** `string` QUALIFIER: id of the persona to score the lead against (required). **mismatchAction** `NONE | TAG | MARK_NOT_QUALIFIED | REMOVE_FROM_CAMPAIGN` QUALIFIER: what to do with a lead that fails the persona. Default MARK\_NOT\_QUALIFIED. **mismatchTagIds** `string[]` QUALIFIER: tags applied on mismatch when mismatchAction is TAG. **mismatchNext** `CONTINUE | STOP` QUALIFIER: whether a mismatched lead continues down the flow. Default STOP. **title** `string` TASK: title of the manual task created for your team. **trigger** `enum (10 values)` TRIGGER only: the condition to branch on. One of If\_Replied, If\_Connected, If\_Interested, If\_InMail\_Open, If\_Email\_Exists, If\_Email\_Opened, If\_Email\_Bounced, If\_Link\_Clicked, If\_Visited\_Profile, CUSTOM. **prompt** `string` TRIGGER with trigger="CUSTOM": the classification prompt for the AI Decision Maker. **branches** `object[]` TRIGGER with trigger="CUSTOM": the two branch labels the model picks between. **yes** `object[]` TRIGGER only: steps to run when the condition is met. Omit to end the flow on this branch. **no** `object[]` TRIGGER only: steps to run when the condition is NOT met. Omit to end the flow on this branch. **title** `string` Label for this flow version, shown in flow history. ## sequence\_leads\_at\_step Read-only Which leads are currently at a given step, and — for failures — why. The drill-down behind a step's pending/completed/failed counter. Takes a step id from `sequence_list` or `flow_get`. For one lead's own position instead use `lead_flow_state`, and to unblock a stuck action `activity_skip`. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **sequenceId** `string` *required* Step id from `sequence_list` or the outline in `flow_get`. **status** `PENDING | COMPLETED | FAILED` Filter to PENDING, COMPLETED or FAILED. **keyword** `string` Search across name and email. **page** `integer (min 1)` (default: 1) 1-indexed page number. **pageSize** `integer (1–100)` (default: 25) Rows per page. ## sequence\_list Read-only The Sequence records the runtime actually executes, created when the campaign launches. Distinct from `flow_get`: the flow is the design, these are the live steps with their ids, delays and copy. Use the ids here with `sequence_leads_at_step`. Empty before the campaign launches, because the records are created at launch — so on a DRAFTED campaign read `flow_get` instead. The `_id` values here are what `sequence_update` patches, and that tool is only safe once the campaign is ACTIVE or PAUSED. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. ## sequence\_step\_stats Read-only Pending / completed / failed counts for every step of a campaign — the funnel view. Use it to find the step where leads stall or fail. Fast, and the right answer to "where are we losing people" on any campaign — prefer it over `analytics_funnel`, which walks every activity row and may not finish on a large campaign. Counts per step; for the leads behind one of them use `sequence_leads_at_step`. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **sequenceId** `string` Narrow to one step. Omit for the whole funnel. ## sequence\_update WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Patch fields on already-materialised sequence steps — the surgical way to fix a typo or swap copy on a campaign that is ALREADY RUNNING (ACTIVE or PAUSED), without re-saving the whole graph and re-evaluating every lead. Pass the step `_id` from `sequence_list` plus only the fields to change. To add, remove or reorder steps, rewrite the sequence with `flow_set`. Do NOT use this on a DRAFTED campaign: launching rebuilds every step from the saved flow graph, which this tool does not touch, so the edit is silently reverted to the original copy the moment the campaign launches. Check `status` with `campaign_get` first. To change a draft's copy, call `flow_set` again with the corrected steps. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **sequences** `object[]` *required* The step patches to apply. **properties** **\_id** `string` *required* Sequence step id from `sequence_list`. # Unified inbox Source: https://docs.linkedcamp.com/mcp/tools/inbox LinkedIn and email conversations with prospects — where replies land, and where you answer them. > [!NOTE] > > Requires the **Inbox** or **Unibox** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`conversation_get`](#conversation_get) | Write | | [`conversation_list`](#conversation_list) | Read-only | | [`conversation_mark_all_read`](#conversation_mark_all_read) | Write | | [`conversation_update`](#conversation_update) | Write | | [`message_delete`](#message_delete) | Write, Destructive | | [`message_draft_ai_reply`](#message_draft_ai_reply) | Write | | [`message_send`](#message_send) | Write, Destructive | | [`saved_reply_list`](#saved_reply_list) | Read-only | | [`saved_reply_upsert`](#saved_reply_upsert) | Write, Destructive | ## conversation\_get Write One thread with its full message history, the lead behind it, and which campaign it came from. Note the side effect: reading a thread marks it seen, so do not call it to browse unless the user wants the badge cleared. This is the prospect-facing exchange. For what an AI agent reasoned on its way to a reply use `agent_logs`, and for the lead's step history `lead_get`. ### Parameters **conversationId** `string` *required* Conversation id, from `conversation_list`. **includeMessages** `boolean` (default: true) Include the full message thread. Can be long. ## conversation\_list Read-only The unified inbox: LinkedIn and email threads with prospects, newest activity first, 20 per page. This is where replies land. Filter by `campaignId` to review one campaign's responses, or `keyword` to find a specific person. Threads, newest first — the conversation view. For one thread's messages use `conversation_get`, for the person behind it `lead_get`, and for campaign reply counts rather than the threads themselves `analytics_campaign`. Nothing here sends: there is no tool to send an inbox message. ### Parameters **linkedAccountId** `string` Only threads on this LinkedIn account. **emailAccountId** `string` Only threads on this mailbox. **campaignId** `string` Campaign id, from `campaign_list` or `campaign_create`. **keyword** `string` Search names and message bodies. **tags** `string` Comma-separated tag ids. **type** `string` Thread kind, e.g. "email". **platform** `string` Filter by channel, e.g. "linkedin" or "email". **page** `integer (min 1)` (default: 1) 1-indexed page number. ## conversation\_mark\_all\_read Write Clear the unread badge across every thread on one LinkedIn account. Blunt and account-wide — it marks everything read, including threads nobody has looked at, so confirm before using it to tidy a badge. For one thread use `conversation_update`. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. ## conversation\_update Write Archive a thread, mark it read, or hand it between the AI assistant and a human. Setting `assistant: false` stops the bot replying so a person can take over — the one call to make when an agent is answering badly and a human needs the thread. Scope is this thread: it does not stop the agent elsewhere (`agent_upsert` with `isActive: false`), detach it from the campaign (`campaign_update`), or change the lead itself (`lead_update`). It cannot send a reply either. ### Parameters **conversationId** `string` *required* Conversation id, from `conversation_list`. **isArchived** `boolean` Move out of the main list without deleting. **seen** `boolean` Mark as read. **assistant** `boolean` Whether the AI agent handles this thread. **pauseBotOnManualMessage** `boolean` Automatically stand the bot down as soon as a human sends a message here. ## message\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Remove a message from the stored thread record. It does NOT unsend anything: the recipient keeps the message on LinkedIn or in their mailbox, so this only edits your own history of the conversation and cannot undo a send. Irreversible and there is no tool to restore it — show the user which message and get an explicit yes first. ### Parameters **messageId** `string` *required* Message id, from `conversation_get` or `message_list`. ## message\_draft\_ai\_reply Write Ask a connected AI provider to draft a reply for a thread, given a prompt. Returns the draft only — give it to the user to send themselves, because sending an inbox message has no tool at all and no substitute. This is a one-off draft from a prompt. A configured agent that replies on its own is `agent_upsert` plus `campaign_update`; to see how such an agent would answer, `agent_query`. Requires an AI provider connected in the web app under Settings - Integrations. ### Parameters **conversationId** `string` *required* Conversation id, from `conversation_list`. **provider** `OPENAI | ANTHROPIC | GEMINI | GROK | DEEPSEEK` *required* Which connected provider to use. Providers are connected in the web app. **prompt** `string` *required* What the reply should do, e.g. "propose three times next week for a 20-min call". ## message\_send WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Send a message into a conversation. THIS DELIVERS TO A REAL PERSON immediately, on LinkedIn or by email depending on the thread, and cannot be recalled or edited — there is no tool to delete a sent message. Show the user the exact text and the recipient, and get an explicit yes in the conversation, before every call. Never send copy the user has not read, and never send to a thread they did not name. Sending by hand also stands the AI agent down on that thread when the agent has `pauseBotOnManualMessage` set, so one manual reply can stop the agent answering there. For a draft the user sends themselves use `message_draft_ai_reply`; to hand a thread to a human without sending anything, `conversation_update` with `assistant: false`. ### Parameters **conversationId** `string` *required* Conversation id, from `conversation_list`. **content** `string` *required* The message, exactly as it will be delivered. **attachment** `object` Optional file to attach; must already be hosted at a fetchable URL. **properties** **url** `string` *required* Publicly reachable URL of the file. **name** `string` File name shown to the recipient, e.g. "case-study.pdf". **type** `string` MIME type, e.g. "application/pdf". ## saved\_reply\_list Read-only Reusable reply snippets your team keeps for common inbox situations. Text a human can copy when replying by hand. These are not sequence steps (`flow_get`), not agent FAQs (`agent_get`), and nothing here is sent automatically. *No parameters.* ## saved\_reply\_upsert WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Create a saved reply, or update one by passing `savedRepliesId`. Stores a snippet for humans to reuse; it does not send anything, schedule anything, or teach an agent — agent wording lives in `agent_upsert`. There is no tool to delete a saved reply. ### Parameters **savedRepliesId** `string` Omit to create a new one. **title** `string` *required* Short label shown in the reply picker. **content** `string` *required* Body. Supports \{\{firstName}}-style merge fields. **assignedUsers** `string[]` Restrict visibility to these team member ids. # Leads and activities Source: https://docs.linkedcamp.com/mcp/tools/leads Prospects, their history, and the individual scheduled actions that make up that history. > [!NOTE] > > Requires the **Campaigns** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`activity_list`](#activity_list) | Read-only | | [`activity_skip`](#activity_skip) | Write, Destructive | | [`lead_add`](#lead_add) | Write | | [`lead_blacklist`](#lead_blacklist) | Write, Destructive | | [`lead_delete`](#lead_delete) | Write, Destructive | | [`lead_export`](#lead_export) | Write | | [`lead_flow_state`](#lead_flow_state) | Read-only | | [`lead_get`](#lead_get) | Read-only | | [`lead_list`](#lead_list) | Read-only | | [`lead_move`](#lead_move) | Write | | [`lead_note_add`](#lead_note_add) | Write | | [`lead_note_update`](#lead_note_update) | Write, Destructive | | [`lead_notes_list`](#lead_notes_list) | Read-only | | [`lead_update`](#lead_update) | Write | ## activity\_list Read-only Completed actions — one row per lead per step. Only COMPLETED activities are returned; the upstream field cannot return PENDING or FAILED rows. To see a failure and its `failedReason`, read one lead with `lead_get`. Note that `status` here filters the LEAD's pipeline status, not the activity's. ### Parameters **campaignId** `string` Campaign id, from `campaign_list` or `campaign_create`. **status** `enum (22 values)` Filters the LEAD pipeline status, not the activity status. Activities are always COMPLETED. **keyword** `string` Free-text search. **range** `object` Date window as \{ from, to } — epoch milliseconds or ISO 8601. Omit for the backend default. **properties** **from** `string | number` Start of the window. **to** `string | number` End of the window. **startDate** `string | number` Alias for `from`. **endDate** `string | number` Alias for `to`. **page** `integer (min 1)` (default: 1) 1-indexed page number. ## activity\_skip WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Mark one pending action SKIPPED, to unblock a lead stuck on a step that will never succeed. That status is the only thing it writes — it does not itself schedule the next step, so do not promise the lead has advanced; re-read with `lead_flow_state` to see what the flow does next. It acts on an activity id, not a lead id. To stop a lead entirely use `lead_update` with `paused` or `isExcluded`. ### Parameters **activityId** `string` *required* Activity id, from `activity_list`. ## lead\_add Write Add one prospect to a campaign by LinkedIn profile URL and/or email. A lead needs at least one of those two — a row with neither is rejected. For more than a handful, use `campaign_upload_leads`. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **profileLink** `string` linkedin.com/in/… profile URL. **email** `string (email)` Required if there is no profile URL. **firstName** `string` Given name. **lastName** `string` Family name. **fullName** `string` Full display name. Use instead of first/last when you only have one string. **designation** `string` Job title. **location** `string` City, region or country. **phone** `string` Phone number. **website** `string` Website URL. **salesNavLink** `string` Sales Navigator profile URL. **recruiterLink** `string` LinkedIn Recruiter profile URL. **personalization** `string` Free-text hook available in copy as \{\{personalization}}. **customFields** `object (free-form)` Extra merge fields, e.g. \{ "recentPost": "…" }, usable as \{\{recentPost}}. ## lead\_blacklist WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Add a lead to the blacklist: their sequence stops and they will be excluded from every future campaign on this account. The right response to an opt-out request. Account-wide and lasting, and no tool removes a blacklist entry — confirm the person and get an explicit yes before calling. To stop sending to someone without excluding them permanently, use `lead_update` with `isExcluded: true` instead. ### Parameters **leadId** `string` *required* Lead id, from `lead_list`. ## lead\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Permanently remove leads from a campaign along with their pending actions. Irreversible — confirm with the user, and prefer `lead_update` with `isExcluded: true` when they only want sending to stop. ### Parameters **campaignId** `string` *required* Campaign id, from `campaign_list` or `campaign_create`. **leadIds** `string[]` Specific leads to delete. **selectAll** `object (free-form)` Delete every lead matching a filter instead of an id list, e.g. \{ "status": "FAILED" }. ## lead\_export Write Generate a CSV of leads filtered by campaign, status and tags. Returns a filename served from the CDN. Use it when the user wants a file. To read leads in the conversation use `lead_list`; for campaign performance numbers rather than people, `campaign_export_stats`. ### Parameters **campaignId** `string` Campaign id, from `campaign_list` or `campaign_create`. **leadStatus** `array of enum (22 values)` Filter by lead pipeline status. **tags** `string[]` Tag ids to filter by, from `tag_list`. ## lead\_flow\_state Read-only Where a lead sits in its campaign sequence right now, when the next action fires, and whether it has been orphaned by a sequence edit. One lead, current position only. For every lead waiting on a given step use `sequence_leads_at_step`; for what a sequence rewrite did to the whole campaign use `flow_audit`. ### Parameters **leadId** `string` *required* Lead id, from `lead_list`. ## lead\_get Read-only Full profile for one lead, plus its complete activity history and current position in the campaign flow — the single call to make when asked "what happened with this person". This is also the only place a FAILED action and its `failedReason` can be read: `activity_list` returns COMPLETED rows only. Do not page through `lead_list` to assemble one lead's history. ### Parameters **leadId** `string` *required* Lead id, from `lead_list`. **includeActivities** `boolean` (default: true) Include the per-step activity history. **includeMessages** `boolean` (default: false) Include the full message thread. Can be long. ## lead\_list Read-only Prospects in a campaign (or across your whole account), with their current pipeline status. The list view: many leads, a few fields each. For one person's full story use `lead_get`, for where they are in the sequence `lead_flow_state`, and for a spreadsheet `lead_export`. Filter by `status` to answer questions like "who replied this week" (REPLIED) or "who accepted but never answered" (CONNECTED). ### Parameters **campaignId** `string` Omit to search every campaign. **keyword** `string` Search name, email or company. **status** `enum (22 values)` Filter by pipeline status. **tags** `string[]` Tag ids — leads must carry at least one. **range** `object` Date window as \{ from, to } — epoch milliseconds or ISO 8601. Omit for the backend default. **properties** **from** `string | number` Start of the window. **to** `string | number` End of the window. **startDate** `string | number` Alias for `from`. **endDate** `string | number` Alias for `to`. **page** `integer (min 1)` (default: 1) 1-indexed page number. **pageSize** `integer (1–100)` (default: 25) Rows per page. ## lead\_move Write Transfer leads into a different campaign. Understand what the backend actually does before offering this, because it is not a relocation: it INSERTS a new lead row in the destination at status FOUND, clearing `acceptedAt` and `repliedAt`, schedules a fresh activity on the destination's first step, and soft-deletes the original with `deleteReason: "MOVED"`. So the prospect restarts from the beginning and the per-step history does not come along — inbox conversations do, they are repointed at the new row. A lead already in the destination by profile URL or email is skipped. The destination must have a LinkedIn account attached or it throws "Destination campaign has no LinkedAccount." — set one with `campaign_update` first. Beware `selectAll`: it moves every lead from the first listed lead's campaign and ignores the rest of the list. ### Parameters **campaignId** `string` *required* Destination campaign id. **leadIds** `string[]` *required* Lead ids, from `lead_list`. **selectAll** `boolean` Move every lead matching the current filter rather than the id list. ## lead\_note\_add Write Write an internal note on a lead. Never sent to the prospect — this is not a way to message anyone, and sending an inbox message has no tool at all. Use `lead_note_update` to change one afterwards; it replaces the whole body. ### Parameters **leadId** `string` *required* Lead id, from `lead_list`. **content** `string` *required* Body text. ## lead\_note\_update WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Rewrite an existing internal note. Replaces the whole body — pass the full text, not a fragment, and read it with `lead_notes_list` first if you do not already have it. Editing a note changes nothing the prospect sees. ### Parameters **noteId** `string` *required* Note id, from `lead_notes_list`. **content** `string` *required* Body text. ## lead\_notes\_list Read-only Internal notes your team has written about a lead. Not visible to the prospect. Notes are free text for humans and have no effect on sending. For the messages actually exchanged with the prospect read `conversation_get`. ### Parameters **leadId** `string` *required* Lead id, from `lead_list`. ## lead\_update Write Edit a lead: correct contact details, pause its sequence, exclude it from sending, or attach merge-field data. `paused: true` freezes just this lead; `isExcluded: true` takes it out of the campaign without deleting the record. Scope is one lead. It cannot pause a whole campaign — pausing a campaign has no tool and is web-app only — and it cannot move a lead elsewhere (`lead_move`) or change its tags for reply classification, which happens on the conversation via `conversation_update`. ### Parameters **leadId** `string` *required* Lead id, from `lead_list`. **email** `string (email)` Email address. **firstName** `string` Given name. **lastName** `string` Family name. **designation** `string` Job title. **phone** `string` Phone number. **website** `string` Website URL. **personalization** `string` Free-text hook for this person, available in copy as \{\{personalization}}. **paused** `boolean` Freeze this lead's sequence without removing it. **isExcluded** `boolean` Remove from sending while keeping the record. **isInterested** `boolean` Mark the reply as positive intent. **seen** `boolean` Mark as read. **customFields** `object (free-form)` Extra merge-field data, e.g. \{ "recentPost": "…" }, usable in copy as \{\{recentPost}}. # Library Source: https://docs.linkedcamp.com/mcp/tools/library The shared assets campaigns draw on: tags, exclusion rules, saved copy, merge fields and blocked dates. | Tool | Kind | | - | - | | [`blacklist_add`](#blacklist_add) | Write | | [`blacklist_add_bulk`](#blacklist_add_bulk) | Write | | [`blacklist_copy`](#blacklist_copy) | Write | | [`blacklist_delete`](#blacklist_delete) | Write, Destructive | | [`blacklist_export`](#blacklist_export) | Write | | [`blacklist_list`](#blacklist_list) | Read-only | | [`holiday_add`](#holiday_add) | Write | | [`holiday_delete`](#holiday_delete) | Write, Destructive | | [`holiday_list`](#holiday_list) | Read-only | | [`hyperise_images`](#hyperise_images) | Read-only | | [`placeholder_add`](#placeholder_add) | Write | | [`placeholder_delete`](#placeholder_delete) | Write, Destructive | | [`placeholder_list`](#placeholder_list) | Read-only | | [`tag_create`](#tag_create) | Write | | [`tag_delete`](#tag_delete) | Write, Destructive | | [`tag_list`](#tag_list) | Read-only | | [`tag_update`](#tag_update) | Write | | [`template_get`](#template_get) | Read-only | | [`template_list`](#template_list) | Read-only | | [`template_upsert`](#template_upsert) | Write, Destructive | ## blacklist\_add Write Exclude prospects by profile URL, company URL, keyword, job title or email. KEYWORD and JOB\_TITLE match as substrings against the profile, so keep them specific — "director" would exclude a very large slice of a search. Account-wide and lasting — it is not a way to skip one prospect in one campaign, which is `lead_update` with `isExcluded`. For a list of rules at once use `blacklist_add_bulk`. There is no tool to delete a rule. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. **type** `PROFILE_URL | COMPANY_URL | KEYWORD | JOB_TITLE | EMAIL` *required* Filter by type. **keyword** `string` *required* The value to match — a URL, an email, or a substring for KEYWORD / JOB\_TITLE. ## blacklist\_add\_bulk Write Add many exclusion rules at once — a competitor domain list, or an opt-out export. Same effect as `blacklist_add`, one call. Rules cannot be removed afterwards by any tool, so review the list with the user before loading it. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. **entries** `object[]` *required* Rules to add, up to 5,000 per call. **properties** **keyword** `string` *required* The value to match — a URL, an email, or a substring for KEYWORD / JOB\_TITLE. **type** `PROFILE_URL | COMPANY_URL | KEYWORD | JOB_TITLE | EMAIL` *required* What `keyword` is matched against. ## blacklist\_copy Write Clone every exclusion rule from one LinkedIn account onto another. Adds to the destination rather than replacing it, and there is no tool to remove rules afterwards — read the destination with `blacklist_list` first so the user knows what the result will be. ### Parameters **linkedAccountId** `string` *required* Source account. **newLinkedAccountId** `string` *required* Destination account. ## blacklist\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Remove an exclusion rule. Prospects it was blocking become targetable again — which is the risk: a rule added for an opt-out, a competitor or a do-not-contact request starts letting those people back into campaigns. Read the rule with `blacklist_list` and show the user exactly what it blocks before calling, and get an explicit yes. This removes a RULE, not a blacklisted person: a lead blacklisted via `lead_blacklist` is a separate record and no tool removes it. ### Parameters **blacklistId** `string` *required* Blacklist rule id, from `blacklist_list`. ## blacklist\_export Write Generate a CSV of every exclusion rule on an account. A file for the user. To read the rules in the conversation use `blacklist_list`. ### Parameters **linkedAccountId** `string` *required* LinkedIn account id, from `linkedin_account_list`. ## blacklist\_list Read-only Exclusion rules for a LinkedIn account. Matching prospects are filtered out before they ever enter a campaign. Per LinkedIn account, not per campaign, so a rule here affects every campaign on that account. Read it when a search returns fewer leads than expected. Excluding one lead from one campaign instead is `lead_update` with `isExcluded`. ### Parameters **linkedAccountId** `string` LinkedIn account id, from `linkedin_account_list`. **page** `integer (min 1)` (default: 1) 1-indexed page number. **pageSize** `integer (1–200)` (default: 50) Rows per page. ## holiday\_add Write Stop all outreach on a given date across every campaign. Every campaign on the account, not one — there is no per-campaign holiday. To stop a single campaign there is no tool at all, and to stop one lead use `lead_update`. Reversible with `holiday_delete`. ### Parameters **blockedAt** `string | number` *required* The date, as epoch milliseconds or ISO 8601. ## holiday\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Remove a blocked date so campaigns send on it again. Removes the block only; it does not resend anything that was skipped while the date was blocked — those sends are gone, not deferred. Check `holiday_list` first so the user knows which date is being unblocked. ### Parameters **holidayId** `string` *required* Blocked-date id, from `holiday_list`. ## holiday\_list Read-only Dates on which no campaign sends anything — public holidays and company shutdowns. Account-wide pauses by date. Read this when a user asks why nothing sent on a particular day. The weekly sending window and timezone are per campaign instead, in `campaign_update`. *No parameters.* ## hyperise\_images Read-only Personalised-image templates from a connected Hyperise account, for use in email and message copy. Pass `sync: true` to re-pull from Hyperise first. Read-only listing. Hyperise itself is connected in the web app under Settings - Integrations, and the image is used by referencing it in copy you pass to `flow_set`. ### Parameters **sync** `boolean` (default: false) Re-pull from the upstream service before returning. ## placeholder\_add Write Define a merge field with a default value, usable as \{\{key}} in any campaign copy. The default is used when a lead has no value of its own, so a sensible default is what stops a message reading oddly. This defines the field for the whole account; it does not set any lead's value, which is `lead_update`. There is no tool to delete a placeholder. ### Parameters **key** `string` *required* Token name, without braces. **value** `string` Fallback value when a lead has none. ## placeholder\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Remove a merge field. Copy still referencing \{\{key}} will render it empty — silently, with no error, so a live campaign starts sending messages with a hole in them. That is the danger here and it is worse than it sounds: nothing fails, the sends just go out wrong. Search existing sequences for the key first, show the user, and get an explicit yes. To change the fallback text instead of removing the field, re-add it with `placeholder_add`. ### Parameters **placeholderId** `string` *required* Merge-field id, from `placeholder_list`. ## placeholder\_list Read-only Team-defined merge fields available in campaign copy, on top of the built-ins (firstName, lastName, designation, location, companyName, industry, senderName, signature). Check this before writing copy that uses a \{\{key}} the user mentions — a placeholder that does not exist renders empty rather than failing, which is how a message goes out with a hole in it. Per-lead values are set on the lead by `lead_update`, not here. ### Parameters **page** `integer (min 1)` (default: 1) 1-indexed page number. ## tag\_create Write Create a tag. The `interest` value decides which bucket it feeds in reply-sentiment analytics. Two different jobs use tags: reply classification (Interested, Not Interested, Replied — reused across campaigns), and identifying one campaign's leads in `campaign_update`. For the second, create a short campaign-specific tag with `interest: "NEUTRAL"` rather than reusing an existing one. ### Parameters **content** `string` *required* Tag label, kept short. For reply classification, something like "Booked a call". For a campaign tag, a shortened form of that campaign's own name — ask the user what to call it rather than inventing one. **interest** `POSITIVE | NEGATIVE | NEUTRAL` *required* POSITIVE, NEGATIVE or NEUTRAL. ## tag\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Delete a tag. Any ASSIGN\_TAG step referencing it stops working, so check your flows first. Leads carrying it lose that classification and it disappears from reply-sentiment reporting, which changes past numbers. Irreversible — show the user what carries it (`tag_list` reports the count) and get an explicit yes. Deleting a campaign's own identity tag makes that campaign's leads indistinguishable in `lead_list`. To rename or reclassify instead, use `tag_update`. ### Parameters **tagId** `string` *required* Tag id, from `tag_list`. ## tag\_list Read-only Tags used to classify leads and replies. Each carries an `interest` of POSITIVE, NEGATIVE or NEUTRAL, which drives reply-sentiment reporting. Tag ids are what ASSIGN\_TAG steps reference. Tags do two unrelated jobs and conflating them causes real damage. The reusable ones listed here — Interested, Not Interested, Replied, Meeting Booked, Deal, Maybe — classify replies and are shared across campaigns. A campaign's own tag, set via `campaign_update`, instead identifies that campaign's leads and must be unique to it: two campaigns sharing one tag cannot have their leads told apart, here or in `lead_list`. So never pass a tag from this list as a campaign tag — mint a short campaign-specific one with `tag_create` (`interest: "NEUTRAL"`). ### Parameters **userId** `string` Sub-account owner id. Omit to act on your own data. ## tag\_update Write Rename a tag or change its sentiment classification. It edits the tag everywhere at once, including on leads already carrying it and in past reply-sentiment reporting — so changing `interest` rewrites history, it does not reclassify going forward only. To tag a lead use `lead_update`; to set a campaign's own tag use `campaign_update`. There is no tool to delete a tag. ### Parameters **tagId** `string` *required* Tag id, from `tag_list`. **content** `string` Body text. **interest** `POSITIVE | NEGATIVE | NEUTRAL` Sentiment bucket this tag feeds in reply analytics. ## template\_get Read-only Full body and subject of one saved template, so you can paste it into a sequence step or adapt it for a new campaign. Returns text. Nothing is applied to a campaign until you pass it to `flow_set` (any step) or `sequence_update` (copy on a running campaign). ### Parameters **templateId** `string` *required* Template id, from `template_list`. ## template\_list Read-only Saved copy your team reuses across campaigns. Paste the body into a step when authoring a sequence. Snippets of copy, not sequence shapes: the prebuilt multi-step sequences `flow_from_template` applies are a different library, matched by name there. These do not attach to a campaign by themselves — read one with `template_get` and pass the text to `flow_set`. *No parameters.* ## template\_upsert WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Save reusable copy. Pass `templateId` to update an existing template rather than create a new one. A snippet in the library, nothing more: saving it does not put it in any campaign, which is `flow_set`, and it is not one of the prebuilt sequence shapes `flow_from_template` applies. Updating replaces the body, so read it with `template_get` first if you do not already have the full text. ### Parameters **templateId** `string` Template id, from `template_list`. **title** `string` *required* Short label. **message** `string` *required* Body. Supports \{\{firstName}}-style merge fields. **subject** `string` For email and InMail templates. **useCredits** `boolean` InMail templates: allow spending InMail credits. **assingedUsers** `string[]` Restrict to these team member ids. Field name is spelled this way in the schema. # Personas Source: https://docs.linkedcamp.com/mcp/tools/personas Ideal-customer definitions. A QUALIFIER step scores each lead against a persona at runtime and routes mismatches out of the sequence. > [!NOTE] > > Requires the **Personas** permission. Tools in this group are hidden from `tools/list` and refused on call when your plan does not grant it. | Tool | Kind | | - | - | | [`persona_create`](#persona_create) | Write | | [`persona_delete`](#persona_delete) | Write, Destructive | | [`persona_get`](#persona_get) | Read-only | | [`persona_list`](#persona_list) | Read-only | | [`persona_update`](#persona_update) | Write, Destructive | ## persona\_create Write Define an ideal customer profile. Returns a `personaId` — a QUALIFIER step needs one, and the flow save is rejected without it, so create the persona before calling `flow_set`. This defines the filter only; it does not add a QUALIFIER step to any sequence. Note QUALIFIER also needs the `Personas` permission on top of Pro. Requires a Pro or Agency plan. ### Parameters **title** `string` *required* Persona name, e.g. "Series B RevOps leaders". **description** `string` Longer explanatory text. **criteria** `object` *required* Qualification rules. Unrecognised keys are stripped server-side. **properties** **jobTitles** `string[]` Titles that qualify, e.g. \["Head of RevOps","VP Sales"]. **jobTitlesExclude** `string[]` Titles that disqualify, e.g. \["Intern","Student"]. **seniority** `string[]` Seniority bands, e.g. \["MANAGER","DIRECTOR","VP","C\_LEVEL"]. **industries** `string[]` Industries that qualify, e.g. \["Computer Software","Financial Services"]. **companySize** `string[]` Headcount bands, e.g. \["51-200","201-500"]. **locations** `string[]` Countries, regions or cities. **keywords** `string[]` Terms that must appear in the profile. **keywordsExclude** `string[]` Terms that disqualify a profile. **yearsExperienceMin** `integer (min 0)` Minimum years of professional experience. **yearsExperienceMax** `integer (min 0)` Maximum years of professional experience. ## persona\_delete WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Delete a persona. Any QUALIFIER step still pointing at it breaks, and that campaign's flow will fail to save until the step is repointed. Check `usageCount` in `persona_list` first and tell the user which campaigns it would break — a persona shared by several flows breaks all of them. Irreversible, so get an explicit yes. To change who qualifies without breaking anything, use `persona_update`. Requires a Pro or Agency plan. ### Parameters **personaId** `string` *required* Persona id, from `persona_list`. ## persona\_get Read-only Full qualification criteria for one persona — job titles, seniority, industries, size, locations and keyword rules — as a QUALIFIER step will apply them. Read this to explain why a lead did or did not qualify. It does not say which leads qualified: for that read the step with `sequence_leads_at_step`. Requires a Pro or Agency plan. ### Parameters **personaId** `string` *required* Persona id, from `persona_list`. ## persona\_list Read-only Ideal-customer definitions used by QUALIFIER steps. `usageCount` shows how many flows reference each one. A persona describes WHO a lead must be to pass a QUALIFIER step. It is not an AI agent (`agent_list`, which writes replies) and not a lead tag (`tag_list`, which classifies replies after the fact). Requires a Pro or Agency plan. *No parameters.* ## persona\_update WriteDestructive > [!WARNING] > > Marked destructive in the protocol — your MCP client asks for confirmation before running it. Change a persona's criteria. Live QUALIFIER steps pick this up on their next evaluation — leads already past the step are not re-scored, so editing a persona never revisits a decision already made. Check `usageCount` in `persona_list` first: a persona shared by several flows changes all of them at once. Requires a Pro or Agency plan. ### Parameters **personaId** `string` *required* Persona id, from `persona_list`. **title** `string` Short label. **description** `string` Longer explanatory text. **criteria** `object` Qualification rules. Unrecognised keys are stripped server-side. **properties** **jobTitles** `string[]` Titles that qualify, e.g. \["Head of RevOps","VP Sales"]. **jobTitlesExclude** `string[]` Titles that disqualify, e.g. \["Intern","Student"]. **seniority** `string[]` Seniority bands, e.g. \["MANAGER","DIRECTOR","VP","C\_LEVEL"]. **industries** `string[]` Industries that qualify, e.g. \["Computer Software","Financial Services"]. **companySize** `string[]` Headcount bands, e.g. \["51-200","201-500"]. **locations** `string[]` Countries, regions or cities. **keywords** `string[]` Terms that must appear in the profile. **keywordsExclude** `string[]` Terms that disqualify a profile. **yearsExperienceMin** `integer (min 0)` Minimum years of professional experience. **yearsExperienceMax** `integer (min 0)` Maximum years of professional experience. # Account settings Source: https://docs.linkedcamp.com/mcp/tools/settings Notifications, your own profile preferences, and the team roster. | Tool | Kind | | - | - | | [`account_settings_update`](#account_settings_update) | Write | | [`help_videos`](#help_videos) | Read-only | | [`notification_list`](#notification_list) | Read-only | | [`notification_mark_read`](#notification_mark_read) | Write | | [`team_members_list`](#team_members_list) | Read-only | ## account\_settings\_update Write Update your own profile and notification preferences: name, language, and the inbox-manager / reporting / notification toggles. Billing details, password and email are intentionally not writable over MCP. Your own user profile only. It does not touch a LinkedIn account's settings (`linkedin_account_update`), a mailbox's (`email_account_update`), or anything on a campaign (`campaign_update`). Billing, team management and tenant configuration are outside this server entirely. ### Parameters **firstName** `string` Given name. **lastName** `string` Family name. **language** `string` UI language code, e.g. "en", "fr", "de", "it", "pt", "ja". **settings** `object` Inbox, reporting and notification toggles. **properties** **inboxManager** `boolean` Let the AI assistant triage the unibox. **suggestReplies** `boolean` Stored preference for AI reply suggestions in the inbox. No current web-app screen exposes it. **sentimentAnalysis** `boolean` Auto-classify replies as positive/negative/neutral. **tagId** `string` Tag applied automatically to positive replies. **addToBlacklist** `boolean` Blacklist a lead automatically when they opt out. **notifyLowProspects** `boolean` Email you when a campaign is running out of leads. **notifyLIDisconnection** `boolean` Email you when a LinkedIn session expires. **notifyEmailDisconnection** `boolean` Email you when a mailbox stops sending. **notifyPositiveReply** `boolean` Email you whenever a lead replies positively. **dailyReport** `boolean` One email each morning summarising yesterday's outreach. **weeklyReport** `boolean` One email each Monday summarising the previous week. ## help\_videos Read-only Product walkthrough videos, for linking a user to the right explainer. Reach for it when the answer is a web-app action with no tool — connecting a LinkedIn account, pausing a campaign, billing — so the user is pointed somewhere useful rather than told no. Links only; it changes nothing and reads no account data, unlike `whoami` or `notification_list`. *No parameters.* ## notification\_list Read-only In-app notifications: disconnected accounts, campaigns running low on prospects, positive replies, limits hit. The platform telling you something needs attention — worth reading when diagnosing why a campaign stopped. These are not prospect replies (`conversation_list`) and not to-dos (`task_list`). Clear the badge with `notification_mark_read`; there is no tool to delete a notification. *No parameters.* ## notification\_mark\_read Write Mark one notification read, or all of them if `notificationId` is omitted — so omitting it clears the whole badge, which is worth confirming first. It only changes read state; the notification is kept, and deleting one is not available. For inbox threads use `conversation_update` or `conversation_mark_all_read` instead. ### Parameters **notificationId** `string` Notification id, from `notification_list`. Omit to act on all of them. ## team\_members\_list Read-only People with access to this account and their roles. Read-only — inviting and removing members is not exposed over MCP, and neither is changing a role. Distinct from [`subaccount_list`](/mcp/tools/subaccounts#subaccount_list), which lists separate agency accounts rather than people on yours — a `userId` for a sub-account comes from there, not from here. *No parameters.* # Sub-accounts Source: https://docs.linkedcamp.com/mcp/tools/subaccounts List the sub-accounts under your agency. Owner-only, and the source of every userId. One tool, and it is the entry point to everything in [MCP for agencies](/mcp/agencies): it is where a `userId` comes from, and seven other tools accept one to answer for that client instead of you. > [!WARNING] > > **Owner-only.** Only an account owner's key can use this. It is not hidden > from the tool list, though — every client is shown the tool, and the refusal > comes when it is called. Seeing it listed does not mean your key can use it. | Tool | Kind | | - | - | | [`subaccount_list`](#subaccount_list) | Read-only | ## subaccount\_list Read-only The active sub-accounts under your agency: id, name, email, plan and state. Scoping is not yours to pass. The list is always your own agency, and never includes you. There is no argument that widens it, and no credential fields are returned. `whoami` reports your role under `_derived` if you need to check before calling. ### Parameters **keyword** `string` Filter by name. **page** `integer` (default: 1) Page number. **pageSize** `integer` (default: 50) Results per page, up to 200. ### What counts as active A sub-account is listed when it is enabled and on a plan. Three kinds are left out: disabled accounts, deleted accounts, and accounts not on a plan yet. `excluded` in the response says how many were left out, so a list shorter than you expected is never silent. An account that is not listed cannot be passed as a `userId` either — one rule decides both, so the list is exactly the set you can act on. > [!NOTE] > > **An empty result is ambiguous, and the tool says so.** You get an empty list > both when you have no active sub-accounts and when the key is not an account > owner — the two cannot be told apart from the response. Do not report "you have > no sub-accounts" from an empty list alone; check the role with `whoami` first. ### Where the id is used Seven tools take a `userId` and answer for that sub-account. Six read; one writes: | Tool | Kind | | - | - | | [`campaign_list`](/mcp/tools/campaigns#campaign_list) | Read-only | | [`linkedin_account_list`](/mcp/tools/accounts#linkedin_account_list) | Read-only | | [`email_account_list`](/mcp/tools/accounts#email_account_list) | Read-only | | [`analytics_campaign`](/mcp/tools/analytics#analytics_campaign) | Read-only | | [`analytics_reporting`](/mcp/tools/analytics#analytics_reporting) | Read-only | | [`tag_list`](/mcp/tools/library#tag_list) | Read-only | | [`agent_duplicate`](/mcp/tools/agents#agent_duplicate) | **Write** — creates an agent inside that account | Take the id from here. Never construct or guess one: a wrong `userId` does not fail quietly, it names a different account. An id from outside your own agency is refused by the server rather than hidden, so there is nothing to retry. Records reached by id — `campaignId`, `leadId`, `conversationId`, `linkedAccountId` — work on a sub-account's records too, including writes. See [MCP for agencies](/mcp/agencies#records-by-id). ### Not the same as team\_members\_list [`team_members_list`](/mcp/tools/settings#team_members_list) lists MANAGERs on your own account — people with access to **your** data. This lists separate accounts with their own data, leads and campaigns. Creating, disabling and licensing sub-accounts happens in the web app; none of it is exposed over MCP. # Troubleshooting Source: https://docs.linkedcamp.com/mcp/troubleshooting Common MCP errors and how to fix them. > [accordion] 401 — the API key was rejected > > The key was rotated, or copied with surrounding whitespace. Re-copy it from Settings → Integrations. In a Claude connector, disconnect and reconnect. Confirm the key is a UUID. > [accordion] 403 — that operation is not available > > You asked for something outside the API key's scope — billing, agency administration, tenant configuration or team management. These are only available in the web app. > [accordion] A campaign will not launch > > Run campaign\_get. Its \_readiness block lists every blocker — usually no sequence, no lead source, no sending account, or a CSV still processing. > [accordion] An AI step fails > > GPT, QUALIFIER and CUSTOM AI Decision Maker each need a connected AI provider (OPENAI, ANTHROPIC, GEMINI, GROK or DEEPSEEK). A QUALIFIER step also needs a personaId. > [accordion] The campaign is active but nothing is sending > > Check linkedin\_account\_get: isValid:false means disconnected, isPaused means stopped, weeklyLimitReached means LinkedIn's invitation ceiling was hit. Also check schedule and holidays. > [accordion] A Pro-only step is refused > > EMAIL, QUALIFIER, GPT, FINDER and EVENT steps need a Pro or Agency plan, as do the If\_Interested and CUSTOM branch conditions and ENGAGEMENT's commentsToAdd. A QUALIFIER step also needs the Personas permission. Call whoami — \_derived lists what is locked. The refusal comes from your plan, so rephrasing will not help. # Plugins Source: https://docs.linkedcamp.com/plugins/overview Ready-made LinkedCamp connections for Claude, ChatGPT, OpenClaw and Hermes Agent. A plugin is the quickest way to connect an assistant to LinkedCamp. It installs the connection to the [LinkedCamp MCP server](/mcp/overview) and a skill that tells the assistant how to build campaigns safely, so you don't have to write a config file. You sign in with your LinkedCamp API key. > [card] [Claude](/mcp/claude) > > Add the connector, sign in once, and run LinkedCamp from any Claude chat. > [card] [ChatGPT](/mcp/chatgpt-plugin) > > Run campaigns, work the inbox and pull analytics from a ChatGPT chat. > [card] [OpenClaw](/mcp/openclaw) > > Run LinkedCamp from WhatsApp, Telegram, Slack, Discord or the Control UI. > [card] [Hermes Agent](/mcp/hermes) > > Sign in once in the browser. Hermes asks before anything changes your account. Every plugin uses the same server and the same 133 tools, so the [scope and safety](/mcp/scope-and-safety) rules and the [tool reference](/mcp/tools/core) apply to all of them. Using another client, such as Claude Code or Cursor? Follow the [MCP quickstart](/mcp/quickstart).