# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Body Parameters

<ParamField type="string">
  The type of blacklist entry.

  Available values: `PROFILE_URL`, `JOB_TITLE`, `KEYWORD`
</ParamField>

<ParamField type="string">
  The value to blacklist. Depending on the type, this could be a LinkedIn profile URL, a job title, or a keyword.
</ParamField>

<ParamField type="string">
  The LinkedIn account email to associate the blacklist with. **Required** if the user has more than one linked LinkedIn account.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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)"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Query Parameters

<ParamField type="string">
  Filter blacklist entries by type.

  Available values: `PROFILE_URL`, `KEYWORD`, `JOB_TITLE`
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="data" type="array">
  Array of blacklist entries.

  <Expandable title="Blacklist Properties">
    <ResponseField name="keyword" type="string">
      The blacklisted value.
    </ResponseField>

    <ResponseField name="type" type="string">
      The blacklist type (PROFILE\_URL, JOB\_TITLE, or KEYWORD).
    </ResponseField>

    <ResponseField name="createdAt" type="number">
      Creation timestamp.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Body Parameters

<ParamField type="string">
  The name of the campaign.
</ParamField>

<ParamField type="string">
  A LinkedIn search URL to source leads from. For example, a LinkedIn People Search URL with filters applied.
</ParamField>

<ParamField type="string">
  The type of outreach sequence to use.

  Available values: `CONNECT`, `MESSAGE`, `INMAIL`, `EMAIL`
</ParamField>

<ParamField type="object">
  The message content for each step of the sequence. Fields vary based on the sequence type.

  <Expandable title="Content Properties">
    <ParamField type="string">
      Connection request note (275 characters max). Used with `CONNECT` sequence.
    </ParamField>

    <ParamField type="string">
      Short connection note (175 characters max). Used with `CONNECT` sequence.
    </ParamField>

    <ParamField type="string">
      First follow-up message.
    </ParamField>

    <ParamField type="string">
      Second follow-up message.
    </ParamField>

    <ParamField type="string">
      Third follow-up message.
    </ParamField>
  </Expandable>
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="campaignId" type="string">
  The ID of the newly created campaign.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Campaign created successfully!",
    "campaignId": "60f7a1b2c3d4e5f6a7b8c9d0"
  }
  ```

  ```json 400 theme={null}
  {
    "success": false,
    "message": "Title is required!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Path Parameters

<ParamField type="string">
  The ID of the campaign. You can get this from the campaign URL or from the [List Campaigns](/api-reference/campaigns/list-campaigns) endpoint.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="data" type="object">
  The campaign details.

  <Expandable title="Campaign Properties">
    <ResponseField name="_id" type="string">
      Campaign ID.
    </ResponseField>

    <ResponseField name="title" type="string">
      Campaign name.
    </ResponseField>

    <ResponseField name="keywords" type="array">
      Search keywords associated with the campaign.
    </ResponseField>

    <ResponseField name="url" type="string">
      LinkedIn search URL.
    </ResponseField>

    <ResponseField name="status" type="string">
      Current campaign status.
    </ResponseField>

    <ResponseField name="total" type="number">
      Total number of leads.
    </ResponseField>

    <ResponseField name="stats" type="object">
      Campaign statistics and metrics.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Path Parameters

<ParamField type="string">
  The ID of the campaign.
</ParamField>

## Query Parameters

<ParamField type="string">
  Optional user ID to filter stats by a specific user.
</ParamField>

<ParamField type="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"}`
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="campaignId" type="string">
  The campaign ID.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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\"}"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Query Parameters

<ParamField type="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`
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="total" type="number">
  Total number of campaigns returned.
</ResponseField>

<ResponseField name="data" type="array">
  Array of campaign objects.

  <Expandable title="Campaign Properties">
    <ResponseField name="_id" type="string">
      Campaign ID.
    </ResponseField>

    <ResponseField name="title" type="string">
      Campaign name.
    </ResponseField>

    <ResponseField name="url" type="string">
      LinkedIn search URL associated with the campaign.
    </ResponseField>

    <ResponseField name="status" type="string">
      Current campaign status.
    </ResponseField>

    <ResponseField name="total" type="number">
      Total number of leads in the campaign.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Path Parameters

<ParamField type="string">
  The ID of the campaign to update.
</ParamField>

## Query Parameters

<ParamField type="string">
  The new status to set for the campaign.

  Available values: `ACTIVE`, `PAUSED`, `COMPLETED`, `FAILED`, `ARCHIVED`
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Campaign PAUSED successfully!"
  }
  ```

  ```json 400 theme={null}
  {
    "success": false,
    "message": "Campaign id is required!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Path Parameters

<ParamField type="string">
  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.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Messages found successfully!"
  }
  ```

  ```json 400 theme={null}
  {
    "success": false,
    "message": "Conversation id is required!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Body Parameters

<ParamField type="string">
  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.
</ParamField>

<ParamField type="string">
  The message content to send. Control characters are automatically sanitized.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Message sent successfully!"
  }
  ```

  ```json 401 theme={null}
  {
    "success": false,
    "message": "Conversation Id is required!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Body Parameters

<ParamField type="string">
  The ID of the campaign to add leads to. The campaign must not be in `DELETED` or `FAILED` status.
</ParamField>

<ParamField type="array">
  Array of lead objects to add.

  <Expandable title="Lead Object Properties">
    <ParamField type="string">
      LinkedIn profile URL of the lead. Supports standard LinkedIn URLs, Sales Navigator URLs, and Recruiter URLs.
    </ParamField>

    <ParamField type="string">
      Lead's first name.
    </ParamField>

    <ParamField type="string">
      Lead's last name.
    </ParamField>

    <ParamField type="string">
      Lead's full name. If not provided but firstName and lastName are, it will be auto-generated.
    </ParamField>
  </Expandable>
</ParamField>

<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.
</Note>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Leads added successfully"
  }
  ```

  ```json 400 theme={null}
  {
    "success": false,
    "message": "Failed to add leads into this campaign!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Path Parameters

<ParamField type="string">
  The ID of the lead.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="data" type="object">
  <Expandable title="Data Properties">
    <ResponseField name="lead" type="object">
      The lead details (same fields as in [List Leads](/api-reference/leads/list-leads)).
    </ResponseField>

    <ResponseField name="company" type="object">
      The lead's associated company data (if available).
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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
    }
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Query Parameters

<ParamField type="string">
  The campaign ID to retrieve leads for.
</ParamField>

<ParamField type="string">
  Filter leads by status.

  Available values: `FOUND`, `VIEWED`, `CONNECT_SENT`, `CONNECTED`, `REPLIED`, `MESSAGE_SENT`, `INMAILS`, `INMAIL_SENT`, `INMAIL_CREDIT`, `WITHDRAWN`
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="total" type="number">
  Total number of leads returned.
</ResponseField>

<ResponseField name="data" type="array">
  Array of lead objects.

  <Expandable title="Lead Properties">
    <ResponseField name="profileLink" type="string">
      LinkedIn profile URL.
    </ResponseField>

    <ResponseField name="salesNavLink" type="string">
      Sales Navigator profile URL.
    </ResponseField>

    <ResponseField name="recruiterLink" type="string">
      Recruiter profile URL.
    </ResponseField>

    <ResponseField name="fullName" type="string">
      Lead's full name.
    </ResponseField>

    <ResponseField name="firstName" type="string">
      Lead's first name.
    </ResponseField>

    <ResponseField name="lastName" type="string">
      Lead's last name.
    </ResponseField>

    <ResponseField name="isPremium" type="boolean">
      Whether the lead has a LinkedIn Premium account.
    </ResponseField>

    <ResponseField name="connectionLevel" type="string">
      LinkedIn connection level (1st, 2nd, 3rd).
    </ResponseField>

    <ResponseField name="status" type="string">
      Current lead status in the campaign.
    </ResponseField>

    <ResponseField name="headline" type="string">
      LinkedIn headline.
    </ResponseField>

    <ResponseField name="designation" type="string">
      Job title/designation.
    </ResponseField>

    <ResponseField name="location" type="string">
      Lead's location.
    </ResponseField>

    <ResponseField name="bio" type="string">
      LinkedIn bio/about section.
    </ResponseField>

    <ResponseField name="contact" type="object">
      Contact information.
    </ResponseField>

    <ResponseField name="profileUrn" type="string">
      LinkedIn profile URN.
    </ResponseField>

    <ResponseField name="conversationId" type="string">
      Associated conversation ID.
    </ResponseField>

    <ResponseField name="conversations" type="array">
      List of associated conversations with type and ID.
    </ResponseField>

    <ResponseField name="campaignId" type="string">
      Campaign this lead belongs to.
    </ResponseField>

    <ResponseField name="companyId" type="string">
      Associated company ID.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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/..."
          }
        ]
      }
    ]
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Body Parameters

<ParamField type="string">
  The LinkedIn profile URL of the lead to update. Must be a valid `linkedin.com` URL.
</ParamField>

<ParamField type="string">
  Updated first name.
</ParamField>

<ParamField type="string">
  Updated last name.
</ParamField>

<ParamField type="string">
  Updated email address.
</ParamField>

<ParamField type="string">
  Email verification status. Defaults to `unknown` if an email is provided without a status.
</ParamField>

<Note>
  Any additional fields passed in the request body will be stored as custom fields on the lead and campaign.
</Note>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Path Parameters

<ParamField type="string">
  The ID of the lead.
</ParamField>

## Query Parameters

<ParamField type="string">
  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
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Lead PAUSE successfully"
  }
  ```

  ```json 200 - Error theme={null}
  {
    "success": false,
    "message": "Lead id is required!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Body Parameters

<ParamField type="string">
  The tag name.
</ParamField>

<ParamField type="string">
  The tag color (hex color code).
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Tag added successfully!"
  }
  ```

  ```json 200 - Error theme={null}
  {
    "success": false,
    "message": "Name is required!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="data" type="array">
  Array of tag objects.

  <Expandable title="Tag Properties">
    <ResponseField name="content" type="string">
      Tag name.
    </ResponseField>

    <ResponseField name="color" type="string">
      Tag color (hex code).
    </ResponseField>

    <ResponseField name="createdAt" type="number">
      Creation timestamp.
    </ResponseField>

    <ResponseField name="updatedAt" type="number">
      Last update timestamp.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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!"
  }
  ```
</ResponseExample>


# 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.
</Note>

## Headers

<ParamField type="string">
  Token from the agency owner account.
</ParamField>

## Query Parameters

<ParamField type="string">
  The email address of the sub-account to retrieve the API token for.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="token" type="string">
  The API token for the specified sub-account.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Api token found successfully!",
    "token": "abc123..."
  }
  ```

  ```json 400 theme={null}
  {
    "success": false,
    "message": "Invalid agency owner token."
  }
  ```
</ResponseExample>


# 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**.
</Note>

## Headers

<ParamField type="string">
  Token from the agency owner account.
</ParamField>

## Body Parameters

<ParamField type="string">
  Email address of the sub-account to cancel.
</ParamField>

<ParamField type="string">
  Reason for cancelling the sub-account.
</ParamField>

<ParamField type="string">
  Detailed description of why the sub-account is being cancelled.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "User deleted successfully!"
  }
  ```

  ```json 401 theme={null}
  {
    "success": false,
    "message": "Invalid user email!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="user" type="object">
  The user account details.

  <Expandable title="User Properties">
    <ResponseField name="email" type="string">
      User's email address.
    </ResponseField>

    <ResponseField name="fullName" type="string">
      User's full name.
    </ResponseField>

    <ResponseField name="apiKey" type="string">
      User's API key.
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="linkedAccount" type="object">
  The linked LinkedIn account details.

  <Expandable title="Linked Account Properties">
    <ResponseField name="fullName" type="string">
      LinkedIn account full name.
    </ResponseField>

    <ResponseField name="email" type="string">
      LinkedIn account email.
    </ResponseField>

    <ResponseField name="isValid" type="boolean">
      Whether the LinkedIn account is valid.
    </ResponseField>

    <ResponseField name="headline" type="string">
      LinkedIn headline.
    </ResponseField>

    <ResponseField name="profileLink" type="string">
      LinkedIn profile URL.
    </ResponseField>

    <ResponseField name="salesNavLink" type="string">
      Sales Navigator profile URL.
    </ResponseField>

    <ResponseField name="recruiterLink" type="string">
      Recruiter profile URL.
    </ResponseField>

    <ResponseField name="profileUrn" type="string">
      LinkedIn profile URN.
    </ResponseField>

    <ResponseField name="profilePic" type="string">
      Profile picture URL.
    </ResponseField>

    <ResponseField name="invalidReason" type="string">
      Reason if the account is invalid.
    </ResponseField>

    <ResponseField name="isPaused" type="boolean">
      Whether the account is paused.
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="emailAccounts" type="array">
  List of connected email accounts.

  <Expandable title="Email Account Properties">
    <ResponseField name="fullName" type="string">
      Email account display name.
    </ResponseField>

    <ResponseField name="email" type="string">
      Email address.
    </ResponseField>

    <ResponseField name="isValid" type="boolean">
      Whether the email account is valid.
    </ResponseField>

    <ResponseField name="isPaused" type="boolean">
      Whether the email account is paused.
    </ResponseField>

    <ResponseField name="type" type="string">
      Email account type.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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"
      }
    ]
  }
  ```
</ResponseExample>


# 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.
</Note>

## Path Parameters

<ParamField type="string">
  The user ID to generate a token for.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="token" type="string">
  The generated authentication token.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Token generated successfully!",
    "token": "U2FsdGVkX1..."
  }
  ```
</ResponseExample>


# 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.
</Note>

## Headers

<ParamField type="string">
  Token from the agency owner account.
</ParamField>

## Body Parameters

<ParamField type="string">
  Email address of the sub-account to pause.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Sub-account paused successfully!"
  }
  ```

  ```json 401 theme={null}
  {
    "success": false,
    "message": "Invalid user email!"
  }
  ```
</ResponseExample>


# 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.
</Note>

## Headers

<ParamField type="string">
  Token from the agency owner account.
</ParamField>

## Body Parameters

<ParamField type="string">
  Full name of the new sub-account user.
</ParamField>

<ParamField type="string">
  Email address for the new sub-account. Must be unique and not already registered.
</ParamField>

<ParamField type="string">
  The plan ID to assign to the sub-account. If not provided, defaults to "CUSTOMER".
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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!"
  }
  ```
</ResponseExample>


# 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.
</Note>

## Headers

<ParamField type="string">
  Token from the agency owner account.
</ParamField>

## Body Parameters

<ParamField type="string">
  Email address of the sub-account to resume.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Sub-account resumed successfully!"
  }
  ```

  ```json 401 theme={null}
  {
    "success": false,
    "message": "Invalid user email!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Body Parameters

<ParamField type="string">
  A descriptive name for the webhook.
</ParamField>

<ParamField type="string">
  The URL that will receive webhook POST requests when the event occurs.
</ParamField>

<ParamField type="string">
  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              |
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Webhook added successfully!"
  }
  ```

  ```json 400 theme={null}
  {
    "success": false,
    "message": "Invalid event!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Path Parameters

<ParamField type="string">
  The ID of the webhook to delete.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "success": true,
    "message": "Webhook deleted successfully!"
  }
  ```

  ```json 200 - Error theme={null}
  {
    "success": false,
    "message": "Invalid webhook ID!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Path Parameters

<ParamField type="string">
  The ID of the webhook.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="data" type="object">
  The webhook details.

  <Expandable title="Webhook Properties">
    <ResponseField name="_id" type="string">
      Webhook ID.
    </ResponseField>

    <ResponseField name="callbackUrl" type="string">
      The callback URL.
    </ResponseField>

    <ResponseField name="title" type="string">
      Webhook name.
    </ResponseField>

    <ResponseField name="events" type="array">
      List of events this webhook listens to.
    </ResponseField>

    <ResponseField name="isValid" type="boolean">
      Whether the webhook is active and valid.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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!"
  }
  ```
</ResponseExample>


# 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

<ParamField type="string">
  Your LinkedCamp API token.
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Whether the request was successful.
</ResponseField>

<ResponseField name="message" type="string">
  A human-readable result message.
</ResponseField>

<ResponseField name="data" type="array">
  Array of webhook objects.

  <Expandable title="Webhook Properties">
    <ResponseField name="_id" type="string">
      Webhook ID.
    </ResponseField>

    <ResponseField name="callbackUrl" type="string">
      The callback URL.
    </ResponseField>

    <ResponseField name="title" type="string">
      Webhook name.
    </ResponseField>

    <ResponseField name="events" type="array">
      List of events this webhook listens to.
    </ResponseField>

    <ResponseField name="isValid" type="boolean">
      Whether the webhook is active and valid.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```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);
  ```
</RequestExample>

<ResponseExample>
  ```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
      }
    ]
  }
  ```
</ResponseExample>


# 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).
</Note>

## 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

<CardGroup>
  <Card title="Campaigns" icon="bullhorn" href="/api-reference/campaigns/create-campaign">
    Create, manage, and track LinkedIn outreach campaigns programmatically.
  </Card>

  <Card title="Leads" icon="users" href="/api-reference/leads/list-leads">
    Add leads to campaigns, update lead data, and track lead statuses.
  </Card>

  <Card title="Conversations" icon="comments" href="/api-reference/conversations/send-message">
    Send messages to prospects and retrieve conversation histories.
  </Card>

  <Card title="Webhooks" icon="webhook" href="/api-reference/webhooks/create-webhook">
    Set up real-time notifications for campaign events like connection accepts or replies.
  </Card>
</CardGroup>

## Quick Start

<Steps>
  <Step title="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.
  </Step>

  <Step title="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
    ```
  </Step>

  <Step title="Start making API calls">
    You're ready to create campaigns, manage leads, and integrate LinkedCamp into your workflows.
  </Step>
</Steps>

## 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)     |