# Extract LinkedIn Company
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company
v1/api/actions.json post /actions/linkedin-extract-company/run/live
Extract detailed information from a LinkedIn company page including name, description, industry, employee count, and more.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Fields temporarily unavailable** — The following output fields may be omitted or `null` until LinkedIn API access is restored:
`tagline`, `linkedin_company_phone`, `followers_count`, `geographic_area`, `locations`, `number_of_locations`, `last_funding_investors`, `crunchbase_company_url`, `last_funding_date`, `last_funding_type`, `last_funding_raised`, `last_funding_currency`, `domain`, `location`, `linkedin_school_id`, `linkedin_page_claimed`, `updated_at`, `affiliates`
# Extract LinkedIn Company Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-async
v1/api/actions.json post /actions/linkedin-extract-company/run/async
Extract detailed information from a LinkedIn company page asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Fields temporarily unavailable** — The following output fields may be omitted or `null` until LinkedIn API access is restored:
`tagline`, `linkedin_company_phone`, `followers_count`, `geographic_area`, `locations`, `number_of_locations`, `last_funding_investors`, `crunchbase_company_url`, `last_funding_date`, `last_funding_type`, `last_funding_raised`, `last_funding_currency`, `domain`, `location`, `linkedin_school_id`, `linkedin_page_claimed`, `updated_at`, `affiliates`
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Company Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-schedule
v1/api/actions.json post /actions/linkedin-extract-company/run/schedule
Schedule extraction of detailed information from a LinkedIn company page at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Fields temporarily unavailable** — The following output fields may be omitted or `null` until LinkedIn API access is restored:
`tagline`, `linkedin_company_phone`, `followers_count`, `geographic_area`, `locations`, `number_of_locations`, `last_funding_investors`, `crunchbase_company_url`, `last_funding_date`, `last_funding_type`, `last_funding_raised`, `last_funding_currency`, `domain`, `location`, `linkedin_school_id`, `linkedin_page_claimed`, `updated_at`, `affiliates`
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Contact
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-contact
v1/api/actions.json post /actions/linkedin-extract-contact/run/live
Extract contact information (email, phone, address) from a LinkedIn profile if available and visible to your account.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract LinkedIn Contact Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-contact-async
v1/api/actions.json post /actions/linkedin-extract-contact/run/async
Extract contact information from a LinkedIn profile asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Contact Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-contact-schedule
v1/api/actions.json post /actions/linkedin-extract-contact/run/schedule
Schedule extraction of contact information from a LinkedIn profile at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Event
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-event
v1/api/actions.json post /actions/linkedin-extract-event/run/live
Extract detailed information from a LinkedIn event including title, description, date, location, and organizer.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract LinkedIn Event Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-event-async
v1/api/actions.json post /actions/linkedin-extract-event/run/async
Extract LinkedIn event information asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract LinkedIn Event Attendees
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-event-attendees
v1/api/actions.json post /actions/linkedin-extract-event-attendees/run/live
Extract the list of attendees registered for a LinkedIn event.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Event Attendees Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-event-attendees-async
v1/api/actions.json post /actions/linkedin-extract-event-attendees/run/async
Extract LinkedIn event attendees asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Event Attendees Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-event-attendees-schedule
v1/api/actions.json post /actions/linkedin-extract-event-attendees/run/schedule
Schedule extraction of LinkedIn event attendees at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Event Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-event-schedule
v1/api/actions.json post /actions/linkedin-extract-event/run/schedule
Schedule extraction of LinkedIn event information at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Group Members
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-group-members
v1/api/actions.json post /actions/linkedin-extract-group-members/run/live
Extract the list of members from a LinkedIn group you belong to.
This action allows you to extract members from a LinkedIn group. You need to be a member of the group to extract its members.
LinkedIn limits group member extraction to 10k members. If the group has more than 10k members, only the first 10k will be returned.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Group Members Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-group-members-async
v1/api/actions.json post /actions/linkedin-extract-group-members/run/async
Extract LinkedIn group members asynchronously with automatic pagination. Results are delivered via callback.
This action allows you to extract members from a LinkedIn group. You need to be a member of the group to extract its members.
LinkedIn limits group member extraction to 10k members. If the group has more than 10k members, only the first 10k will be returned.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Job
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-job
v1/api/actions.json post /actions/linkedin-extract-job/run/live
Extract detailed information from a LinkedIn job posting including title, company, description, requirements, and application details.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract LinkedIn Job Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-job-async
v1/api/actions.json post /actions/linkedin-extract-job/run/async
Extract LinkedIn job posting information asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Job Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-job-schedule
v1/api/actions.json post /actions/linkedin-extract-job/run/schedule
Schedule extraction of LinkedIn job posting information at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Licenses & Certifications
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-licenses-certifications
v1/api/actions.json post /actions/linkedin-extract-licenses-certifications/run/live
Extract licenses and certifications from a LinkedIn profile including credential name, issuing organization, and dates.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Licenses & Certifications Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-licenses-certifications-async
v1/api/actions.json post /actions/linkedin-extract-licenses-certifications/run/async
Extract licenses and certifications from a LinkedIn profile asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Licenses & Certifications Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-licenses-certifications-schedule
v1/api/actions.json post /actions/linkedin-extract-licenses-certifications/run/schedule
Schedule extraction of licenses and certifications from a LinkedIn profile at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Profile Handle
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-linkedin-profile-handle
v1/api/actions.json post /actions/linkedin-extract-linkedin-profile-handle/run/live
Resolve a LinkedIn profile handle from a Sales Navigator profile ID or URL.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Notes
Resolve a **LinkedIn profile handle** from a Sales Navigator profile identifier.
**Input** (one of):
* `sales_navigator_profile_id` (ACo, ACw, or ACr)
* `sales_navigator_profile_url`
**Output highlights:** `linkedin_profile_handle`, `linkedin_profile_url`, `linkedin_profile_id`, `sales_navigator_profile_id`, `sales_navigator_profile_url`
* The returned `sales_navigator_profile_id` is always an **ACo**, even if the input was **ACw** or **ACr**.
* If the Sales Navigator profile does not exist, the API returns **`STATUS_404`**.
# Extract LinkedIn Profile Handle Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-linkedin-profile-handle-async
v1/api/actions.json post /actions/linkedin-extract-linkedin-profile-handle/run/async
Resolve a LinkedIn profile handle from a Sales Navigator profile ID or URL asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Notes
Resolve a **LinkedIn profile handle** from a Sales Navigator profile identifier.
**Input** (one of):
* `sales_navigator_profile_id` (ACo, ACw, or ACr)
* `sales_navigator_profile_url`
**Output highlights:** `linkedin_profile_handle`, `linkedin_profile_url`, `linkedin_profile_id`, `sales_navigator_profile_id`, `sales_navigator_profile_url`
* The returned `sales_navigator_profile_id` is always an **ACo**, even if the input was **ACw** or **ACr**.
* If the Sales Navigator profile does not exist, the API returns **`STATUS_404`**.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Profile Handle Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-linkedin-profile-handle-schedule
v1/api/actions.json post /actions/linkedin-extract-linkedin-profile-handle/run/schedule
Schedule resolution of a LinkedIn profile handle from a Sales Navigator profile ID or URL.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Notes
Resolve a **LinkedIn profile handle** from a Sales Navigator profile identifier.
**Input** (one of):
* `sales_navigator_profile_id` (ACo, ACw, or ACr)
* `sales_navigator_profile_url`
**Output highlights:** `linkedin_profile_handle`, `linkedin_profile_url`, `linkedin_profile_id`, `sales_navigator_profile_id`, `sales_navigator_profile_url`
* The returned `sales_navigator_profile_id` is always an **ACo**, even if the input was **ACw** or **ACr**.
* If the Sales Navigator profile does not exist, the API returns **`STATUS_404`**.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people
v1/api/actions.json post /actions/linkedin-extract-people/run/live
Extract detailed profile information from LinkedIn people including name, headline, experience, education, and skills.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Fields deprecated** — The following output fields may be omitted or `null`:
* `birth_date`
* `linkedin_thread_id`
* `connected_at`
When enabled, returns the first **5 companies' experiences** (count varies by profile). For full work history, use [`linkedin-extract-people-experiences`](/v1/api/actions/linkedin-extract-people-experiences).
| Field | Description |
| -------------- | ------------------------------------------------------------------------------ |
| `date` | Employment date ranges only — e.g. `Sep 2024 - Present`, `Sep 2005 - Aug 2008` |
| `title` | Job title |
| `company_name` | Company name |
When enabled, returns **one or two skills** (varies by profile). For full skills list, use [`linkedin-extract-people-skills`](/v1/api/actions/linkedin-extract-people-skills).
When enabled, returns optional profile sections:
`education` · `languages` · `volunteer_experiences` · `summary` · `company_name` · `job_title` · `linkedin_company_url`
**Education fields** (when `education` is included):
| Field | Description |
| ---------------- | ---------------------------------------------------------------------------- |
| `title` | `degreeName` + `fieldOfStudy` (e.g. `Bachelor of Science, Computer Science`) |
| `degree_name` | First part of `title` when comma-separated; otherwise empty |
| `field_of_study` | Second part of `title` when comma-separated; otherwise empty |
When enabled, returns:
`linkedin_company_url` · `connection_degree` · `number_followers` · `number_connections`
**`profile_country`** — Inferred from recent experience locations when LinkedIn does not expose it directly. Remote and hybrid locations are excluded.
# Extract LinkedIn People Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-async
v1/api/actions.json post /actions/linkedin-extract-people/run/async
Extract detailed LinkedIn profile information asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Fields deprecated** — The following output fields may be omitted or `null`:
* `birth_date`
* `linkedin_thread_id`
* `connected_at`
When enabled, returns the first **5 companies' experiences** (count varies by profile). For full work history, use [`linkedin-extract-people-experiences`](/v1/api/actions/linkedin-extract-people-experiences).
| Field | Description |
| -------------- | ------------------------------------------------------------------------------ |
| `date` | Employment date ranges only — e.g. `Sep 2024 - Present`, `Sep 2005 - Aug 2008` |
| `title` | Job title |
| `company_name` | Company name |
When enabled, returns **one or two skills** (varies by profile). For full skills list, use [`linkedin-extract-people-skills`](/v1/api/actions/linkedin-extract-people-skills).
When enabled, returns optional profile sections:
`education` · `languages` · `volunteer_experiences` · `summary` · `company_name` · `job_title` · `linkedin_company_url`
**Education fields** (when `education` is included):
| Field | Description |
| ---------------- | ---------------------------------------------------------------------------- |
| `title` | `degreeName` + `fieldOfStudy` (e.g. `Bachelor of Science, Computer Science`) |
| `degree_name` | First part of `title` when comma-separated; otherwise empty |
| `field_of_study` | Second part of `title` when comma-separated; otherwise empty |
When enabled, returns:
`linkedin_company_url` · `connection_degree` · `number_followers` · `number_connections`
**`profile_country`** — Inferred from recent experience locations when LinkedIn does not expose it directly. Remote and hybrid locations are excluded.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Educations
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-educations
v1/api/actions.json post /actions/linkedin-extract-people-educations/run/live
Extract education history from LinkedIn profiles including schools, degrees, fields of study, and dates.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn People Educations Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-educations-async
v1/api/actions.json post /actions/linkedin-extract-people-educations/run/async
Extract LinkedIn profile education history asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Educations Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-educations-schedule
v1/api/actions.json post /actions/linkedin-extract-people-educations/run/schedule
Schedule extraction of LinkedIn profile education history at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Experiences
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-experiences
v1/api/actions.json post /actions/linkedin-extract-people-experiences/run/live
Extract detailed work experience history from LinkedIn profiles including job titles, companies, dates, and descriptions.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
| Field | Description |
| -------------- | ------------------------------------------------- |
| `title` | Job title |
| `company_name` | Company name |
| `date` | Employment date range — e.g. `Sep 2024 - Present` |
Tenure and duration values are not placed in `company_name` or `title`.
# Extract LinkedIn People Experiences Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-experiences-async
v1/api/actions.json post /actions/linkedin-extract-people-experiences/run/async
Extract LinkedIn profile work experiences asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
| Field | Description |
| -------------- | ------------------------------------------------- |
| `title` | Job title |
| `company_name` | Company name |
| `date` | Employment date range — e.g. `Sep 2024 - Present` |
Tenure and duration values are not placed in `company_name` or `title`.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Experiences Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-experiences-schedule
v1/api/actions.json post /actions/linkedin-extract-people-experiences/run/schedule
Schedule extraction of LinkedIn profile work experiences at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
| Field | Description |
| -------------- | ------------------------------------------------- |
| `title` | Job title |
| `company_name` | Company name |
| `date` | Employment date range — e.g. `Sep 2024 - Present` |
Tenure and duration values are not placed in `company_name` or `title`.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-schedule
v1/api/actions.json post /actions/linkedin-extract-people/run/schedule
Schedule extraction of detailed LinkedIn profile information at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Fields deprecated** — The following output fields may be omitted or `null`:
* `birth_date`
* `linkedin_thread_id`
* `connected_at`
When enabled, returns the first **5 companies' experiences** (count varies by profile). For full work history, use [`linkedin-extract-people-experiences`](/v1/api/actions/linkedin-extract-people-experiences).
| Field | Description |
| -------------- | ------------------------------------------------------------------------------ |
| `date` | Employment date ranges only — e.g. `Sep 2024 - Present`, `Sep 2005 - Aug 2008` |
| `title` | Job title |
| `company_name` | Company name |
When enabled, returns **one or two skills** (varies by profile). For full skills list, use [`linkedin-extract-people-skills`](/v1/api/actions/linkedin-extract-people-skills).
When enabled, returns optional profile sections:
`education` · `languages` · `volunteer_experiences` · `summary` · `company_name` · `job_title` · `linkedin_company_url`
**Education fields** (when `education` is included):
| Field | Description |
| ---------------- | ---------------------------------------------------------------------------- |
| `title` | `degreeName` + `fieldOfStudy` (e.g. `Bachelor of Science, Computer Science`) |
| `degree_name` | First part of `title` when comma-separated; otherwise empty |
| `field_of_study` | Second part of `title` when comma-separated; otherwise empty |
When enabled, returns:
`linkedin_company_url` · `connection_degree` · `number_followers` · `number_connections`
**`profile_country`** — Inferred from recent experience locations when LinkedIn does not expose it directly. Remote and hybrid locations are excluded.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Skills
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-skills
v1/api/actions.json post /actions/linkedin-extract-people-skills/run/live
Extract the skills listed on a LinkedIn profile including skill names and endorsement counts.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn People Skills Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-skills-async
v1/api/actions.json post /actions/linkedin-extract-people-skills/run/async
Extract LinkedIn profile skills asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Skills Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-skills-schedule
v1/api/actions.json post /actions/linkedin-extract-people-skills/run/schedule
Schedule extraction of LinkedIn profile skills at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Post
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post
v1/api/actions.json post /actions/linkedin-extract-post/run/live
Extract detailed information from a LinkedIn post including content, author, engagement metrics, and media.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract LinkedIn Post Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-async
v1/api/actions.json post /actions/linkedin-extract-post/run/async
Extract LinkedIn post information asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Post Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-schedule
v1/api/actions.json post /actions/linkedin-extract-post/run/schedule
Schedule extraction of LinkedIn post information at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Profile Id
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-salesnavigator-profile-id
v1/api/actions.json post /actions/linkedin-extract-salesnavigator-profile-id/run/live
Resolve a Sales Navigator profile ID from a LinkedIn profile handle or URL.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Notes
Resolve a **Sales Navigator profile ID** from a LinkedIn profile identifier.
**Input** (one of):
* `linkedin_profile_handle`
* `linkedin_profile_url`
**Output highlights:** `sales_navigator_profile_id`, `sales_navigator_profile_url`, `linkedin_profile_handle`, `linkedin_profile_url`, `linkedin_profile_id`
* The returned `sales_navigator_profile_id` is always an **ACo**, even if a Sales Navigator URL in the input used another ID format.
* If the LinkedIn handle or profile does not exist, the API returns **`STATUS_404`**.
# Extract Sales Navigator Profile Id Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-salesnavigator-profile-id-async
v1/api/actions.json post /actions/linkedin-extract-salesnavigator-profile-id/run/async
Resolve a Sales Navigator profile ID from a LinkedIn profile handle or URL asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Notes
Resolve a **Sales Navigator profile ID** from a LinkedIn profile identifier.
**Input** (one of):
* `linkedin_profile_handle`
* `linkedin_profile_url`
**Output highlights:** `sales_navigator_profile_id`, `sales_navigator_profile_url`, `linkedin_profile_handle`, `linkedin_profile_url`, `linkedin_profile_id`
* The returned `sales_navigator_profile_id` is always an **ACo**, even if a Sales Navigator URL in the input used another ID format.
* If the LinkedIn handle or profile does not exist, the API returns **`STATUS_404`**.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Profile Id Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-salesnavigator-profile-id-schedule
v1/api/actions.json post /actions/linkedin-extract-salesnavigator-profile-id/run/schedule
Schedule resolution of a Sales Navigator profile ID from a LinkedIn profile handle or URL.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Notes
Resolve a **Sales Navigator profile ID** from a LinkedIn profile identifier.
**Input** (one of):
* `linkedin_profile_handle`
* `linkedin_profile_url`
**Output highlights:** `sales_navigator_profile_id`, `sales_navigator_profile_url`, `linkedin_profile_handle`, `linkedin_profile_url`, `linkedin_profile_id`
* The returned `sales_navigator_profile_id` is always an **ACo**, even if a Sales Navigator URL in the input used another ID format.
* If the LinkedIn handle or profile does not exist, the API returns **`STATUS_404`**.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract my LinkedIn User Profile
Source: https://docs.edges.run/v1/api/actions/linkedin-me
v1/api/actions.json post /actions/linkedin-me/run/live
Extract your own LinkedIn profile information including name, headline, connections, and more.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract my LinkedIn User Profile Async
Source: https://docs.edges.run/v1/api/actions/linkedin-me-async
v1/api/actions.json post /actions/linkedin-me/run/async
Extract your own LinkedIn profile information asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract my LinkedIn User Profile Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-me-schedule
v1/api/actions.json post /actions/linkedin-me/run/schedule
Schedule extraction of your own LinkedIn profile information at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# LinkedIn People Id From Sales Navigator Id
Source: https://docs.edges.run/v1/api/actions/linkedin-peopleid-from-salesnavigatorid
v1/api/actions.json post /actions/linkedin-peopleid-from-salesnavigatorid/run/live
Convert a Sales Navigator lead ID to a LinkedIn people ID for profile enrichment.
# LinkedIn People Id From Sales Navigator Id Async
Source: https://docs.edges.run/v1/api/actions/linkedin-peopleid-from-salesnavigatorid-async
v1/api/actions.json post /actions/linkedin-peopleid-from-salesnavigatorid/run/async
Convert a Sales Navigator lead ID to a LinkedIn people ID asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# LinkedIn People Id From Sales Navigator Id Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-peopleid-from-salesnavigatorid-schedule
v1/api/actions.json post /actions/linkedin-peopleid-from-salesnavigatorid/run/schedule
Schedule conversion of Sales Navigator lead IDs to LinkedIn people IDs at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Get a Run Callback
Source: https://docs.edges.run/v1/api/callbacks/get
v1/api/actions.json get /runs/callbacks/{callback_uid}
Retrieve a specific callback for a run by its unique identifier
# List Run Callbacks
Source: https://docs.edges.run/v1/api/callbacks/list
v1/api/actions.json get /runs/callbacks
List and filter callbacks for runs with pagination and status filtering
# Replay a Run Callback
Source: https://docs.edges.run/v1/api/callbacks/replay
v1/api/actions.json post /runs/callbacks/{callback_uid}/replay
Retry delivery of a failed callback for a run to your webhook endpoint
**How replay works:**
* Each replay creates a new callback (up to 3 total replays)
* You can only replay the original callback, not callback responses
* This helps you track each attempt and identify specific issues with your webhook URL
**When to use replay:**
* Your webhook URL was temporarily unavailable
* You received a callback but want to retry processing
* You need to debug callback delivery issues
# Create an Identity
Source: https://docs.edges.run/v1/api/identities/create
v1/api/business.json post /identities
Create an identity
To automate Actions with Edges, you'll need to create Identities. You have two options:
1. **Synchronize Your Own Users**: Connect your existing users as identities
2. **Use Managed Accounts**: Use our pre-configured accounts
Learn more about these options in our guide on [When LinkedIn Identities Options: Sync, Rent, or Use Managed](/v1/identities/sync-vs-managed).
## Identity Types
When creating an identity, you can specify its type:
* **`standard`** (default): Standard identity included in your plan. All actions consume credits at the normal rate.
* **`engagement`**: Engagement identity that allows running a broad set of LinkedIn outreach actions (connect, message, follow, like, comment, etc.) **without consuming credits**. Ideal for building SaaS products or AI agents that enable users to engage on LinkedIn or create outreach sequences.
Engagement Identities must be **enabled first** from the [Developer Settings](https://app.edges.run/settings/developers) page and require billing details to be filled. They are **billed monthly** based on the peak number of active Engagement Identities during your billing cycle (starting at \$7.99/identity/month).
Use Engagement Identities for high-volume, repetitive outreach actions (connect, message, follow) and keep standard identities for more occasional or data extraction workflows. See [Engagement Identities](/v1/identities/engagement) for more details.
**Important**: The identity `type` cannot be changed after creation. If you need to change an identity's type, you must delete the existing identity and create a new one with the desired type.
Once you've created an Identity, connect them to platforms like LinkedIn using the [Connect an Identity's' Integration](/v1/api/integrations/connect) endpoint.
Read everything you need to know about [Adding & Managing Identities](/v1/identities/add-manage-identities).
`identity_login_links` are secure, 48-hour valid URLs that let users connect their integration accounts (like LinkedIn) without a browser extension.
Users authenticate through our white-labeled interface, and you can share these links via email or embed them in your product.
Once connected, the integration is ready to use with our API.
# Delete an Identity
Source: https://docs.edges.run/v1/api/identities/delete
v1/api/business.json delete /identities/{identity_uid}
Delete a Identity
# Get an Identity
Source: https://docs.edges.run/v1/api/identities/get
v1/api/business.json get /identities/{identity_uid}
Get a Identity
# Get Identity Limits
Source: https://docs.edges.run/v1/api/identities/limits
v1/api/actions.json get /identities/{identity_uid}/actions/{action_slug}/limits
Retrieve usage limits and consumption data for a specific action on a given identity
This endpoint retrieves the current usage limits and consumption data for a specific action on a given identity. It helps you monitor how close an identity is to reaching its limits for a particular action.
Edges applies **Smart Limits** to prevent LinkedIn accounts from getting restricted. These limits operate on a 24-hour sliding window and help stay within LinkedIn's daily action caps.
This endpoint is specific to Edges Smart Limits and tracks only actions performed within the platform. It does not guarantee that LinkedIn won't impose its own restrictions.
Evaluating limits in real-time is a consuming operation. Use this endpoint sparingly to avoid performance issues. It is rate limited along with other identity management operations.
For more details about Smart Limits, best practices, and how to handle rate limits, see our [LinkedIn Rate Limits documentation](/v1/linkedin/limits).
## Understanding the Response
Some actions consume **multiple limits** internally. For example, `linkedin-message-profile` may consume `LK_MESSAGES_SENT`, `LK_PROFILE_ENRICHMENTS`, and `LK_GET_CONTACT_INFO` depending on the operation. This is why querying limits for a single action may return multiple limit objects in the `limits` array.
When checking if an action can be performed, ensure **all** returned limits have `has_reached_limit: false`. If any limit is reached, the action may be blocked.
For a full list of limit slugs and their meanings, see the [LinkedIn Commercial Limits table](/v1/linkedin/limits#linkedin-commercial-limits).
# List Identities
Source: https://docs.edges.run/v1/api/identities/list
v1/api/business.json get /identities
List all Identities
# Generate Login Links
Source: https://docs.edges.run/v1/api/identities/login-links
v1/api/business.json post /identities/{identity_uid}/generate-login-links
Generate a new login link to allow native login for an identity with username and password.
Generated login links are valid for **48 hours**. After that, they expire and users must use a newly generated link to connect their account.
# Update an Identity
Source: https://docs.edges.run/v1/api/identities/update
v1/api/business.json put /identities/{identity_uid}
Update an Identity
Update an identity's name and timezone. You can modify these fields at any time after creation.
**Identity type cannot be changed**: The `type` field (standard or engagement) is set during creation and cannot be modified via the update endpoint. If you need to change an identity's type, you must:
1. Delete the existing identity using the [Delete an Identity](/v1/api/identities/delete) endpoint
2. Create a new identity with the desired type using the [Create an Identity](/v1/api/identities/create) endpoint
Before deleting an identity to change its type, make sure to:
* Note any connected integrations (you'll need to reconnect them to the new identity)
* Consider the impact on any scheduled actions or workflows
* Be aware that deleting an engagement identity may affect your monthly billing cycle
# Connect an Identity’s Integration
Source: https://docs.edges.run/v1/api/integrations/connect
v1/api/business.json post /identities/{identity_uid}/integrations/{integration}
Connect an Identity to a platform like LinkedIn by authenticating an user with cookies or credentials.
Connect an identity to an integration. An identity can only be connected to one integration per platform (one LinkedIn account for example).
The data of an existing integration will be updated each time you call this endpoint if it has been connected before.
Before connecting an Integration, you must first [Create an
Identity](/v1/api/identities/create) to associate the integration with.
The response's object with meta fields is also returned on your integration webhook present on your [developpers settings](https://app.edges.run/settings/developers)
If you're looking to connect natively to LinkedIn using email and password,
check out this specific endpoint: [Connect a LinkedIn Account
(Username/Password)](/v1/api/linkedin/authentication)
# Delete an Identity’s Integration
Source: https://docs.edges.run/v1/api/integrations/delete
v1/api/business.json delete /identities/{identity_uid}/integrations/{integration}
Disconnect a identity from a specific integration.
When the integration is deleted successfully, Edges posts to your workspace **integration webhook** (if you configured one under [Developer settings](https://app.edges.run/settings/developers)).
The payload uses `event_type: "integration"` and **`event: "DELETED"`** so you can tear down local state or stop workflows tied to that identity and integration.
For the full JSON shape and other `event` values, see [LinkedIn integration webhooks — Setup process](/v1/identities/linkedin#setup-process).
# Get an Identity’s Integration
Source: https://docs.edges.run/v1/api/integrations/get
v1/api/business.json get /identities/{identity_uid}/integrations/{integration}
Retrieve the current authentication details and connection status of an Identity’s integration, e.g. LinkedIn.
# Introduction
Source: https://docs.edges.run/v1/api/introduction
API Reference Version 1
Welcome to Edges API v1, which allows you to **automate Actions in
Real-Time**. You can also manage Identities and their Integrations. If you
encounter any issues using this API, feel free to reach out at
[support@edges.run ](mailto:support@edges.run).
If you're new to Edges, we strongly recommend reviewing the following resources before diving into the API:
* [Quickstart](/v1/quickstart) – A brief overview of how to use the API.
* [Core Concepts](/v1/core-concepts) – A description of core objects and how to interact with them.
## Authentication
To authorize requests, add `X-API-Key: ` to all API requests (case insensitive). We also recommend `Accept: application/json` so responses are clearly requested as JSON.
Here’s an example of a request to the API:
```bash theme={null}
curl --location 'https://api.edges.run/v1/workspaces' \
--header 'Accept: application/json' \
--header 'X-API-Key: '
```
All subsequent examples will use this header as part of the request.
To get your API Key, go to [Developer Settings](https://app.edges.run/settings/developers) and copy the appropriate values.
Each user of your workspace has their own unique API Key that is tied to their account. API Keys
are not shared across the workspace.
## Playground
Each API endpoint has an interactive playground where you can test requests directly.
## SDK
We're thrilled to introduce [**Edges's first TypeScript SDK**](https://www.npmjs.com/package/@edgesrun/sdk).
This type-safe SDK offers a streamlined way to interact with our API through a single Edges class.
It handles authentication and provides access to `Core` endpoints and integrations including `LinkedIn` and `Sales Navigator`.
# Connect a LinkedIn Account (Username/Password)
Source: https://docs.edges.run/v1/api/linkedin/authentication
v1/api/business.json post /identities/{identity_uid}/integrations/linkedin
Create or update a LinkedIn account
Before connecting a LinkedIn account using email and password authentication, you must first [Create an Identity](/v1/api/identities/create) to associate the account with.
Once you have created an identity, you can use this endpoint to connect their LinkedIn account using their email and password credentials.
**Checkpoint Handling**: LinkedIn will likely require you to complete a checkpoint. Use the [Resolve LinkedIn Checkpoint](/v1/api/linkedin/checkpoint) endpoint to handle this.
The checkpoint endpoint supports various verification methods including mobile app approval, SMS codes, email verification, 2FA codes, and more. See the checkpoint documentation for detailed handling instructions for each checkpoint type.
# Resolve LinkedIn Checkpoint
Source: https://docs.edges.run/v1/api/linkedin/checkpoint
v1/api/business.json post /identities/{identity_uid}/integrations/linkedin/checkpoint
Resolve a Checkpoint or check for in-app resolution.
This endpoint resolves LinkedIn authentication checkpoints that occur during the login process. LinkedIn may require additional verification steps to complete the authentication.
## Checkpoint Types
LinkedIn may present different types of checkpoints during authentication. Here's how to handle each one:
### **`IN_APP_VALIDATION`** - Mobile App Approval
The user must approve the login in their LinkedIn mobile app.
**For `IN_APP_VALIDATION` checkpoints**:
1. **User Action**: The user must approve the login in their LinkedIn mobile app
2. **Your Action**: Poll this endpoint with an empty request body `{}`
3. **Timing**: Check every 5-10 seconds with a maximum timeout of 5 minutes
4. **Completion**: Stop when you receive a success response or permanent error
**Note**: No verification code is required for mobile app authentication.
### **`2FA`** - Two-Factor Authentication
Two-factor authentication via authenticator app.
* **Action**: Provide the 6-digit code from the user's authenticator app
* **Timing**: Codes expire quickly, so prompt users to provide them promptly
* **Request**: Send the code in the request body: `{"code": "123456"}`
### **`OTP`** - One-Time Password (SMS)
One-time password sent via SMS to the user's phone number.
* **Action**: Provide the SMS code sent to the user's phone
* **Timing**: Codes typically expire within 10-15 minutes
* **Request**: Send the code in the request body: `{"code": "123456"}`
### **`EMAIL`** - Email Verification
Verification code sent to the user's email address.
* **Action**: Provide the code sent to the user's registered email
* **Note**: Check spam/junk folders if the email doesn't arrive
* **Request**: Send the code in the request body: `{"code": "123456"}`
### **`PHONE_REGISTER`** - Phone Number Verification
Phone number verification required by LinkedIn.
* **Action**: User needs to verify their phone number with LinkedIn
* **Note**: May require providing a new phone number or confirming existing one
* **Request**: Send any required verification code: `{"code": "123456"}`
### **`CAPTCHA`** - Visual/Audio Challenge
Visual or audio challenge to prove human interaction.
* **Action**: Poll **`POST .../integrations/linkedin/checkpoint`** with `{}` until the challenge clears; then handle any **next** checkpoint type using this page.
* **Request**: `{}` for this polling flow (no code in the body)
### **`LOGIN_FORM`** - Additional Login Fields
Additional login form fields required by LinkedIn.
* **Action**: LinkedIn may request additional information (security questions, etc.)
* **Note**: Contact support if this checkpoint type is encountered
* **Request**: Contact support with the `identity_uid` for assistance
### **`UNKNOWN`** - Unrecognized Checkpoint
Unrecognized checkpoint type.
* **Action**: Contact support with the `identity_uid` for assistance
* **Note**: This may indicate a new checkpoint type that needs to be handled
## Request Examples
**For checkpoint types requiring codes:**
```json theme={null}
{
"code": "123456"
}
```
**For `IN_APP_VALIDATION` or `CAPTCHA` checkpoints:**
```json theme={null}
{}
```
## Error Handling
* **`IN_APP_CHALLENGE_PENDING`**: Continue polling for `IN_APP_VALIDATION` checkpoints
* **`IN_APP_CHALLENGE_EXPIRED`**: Restart the authentication process
* **`2FA_VALIDATION_EXPIRED`**: Restart the authentication process
* **`CHECKPOINT_MISSING_DATA`**: Restart the authentication process
* **`INVALID_CODE`**: The provided code is incorrect, try again
# Cancel a Run
Source: https://docs.edges.run/v1/api/runs/cancel
v1/api/actions.json post /runs/{run_uid}/cancel
`uid` is used for all the endpoints and Run manipulation.
The `id` is an internal identifier returned to smooth and improve speed and accuracy if you have questions about your runs you will want
to submit to the team.
This endpoint only applies to **async** and **schedule** execution modes. Live runs cannot be canceled as they are synchronous.
Canceling a run will stop all pending operations. Results already processed will still be available, but no further callbacks will be sent for this run.
# Continue an incremental Run
Source: https://docs.edges.run/v1/api/runs/continue
v1/api/actions.json post /runs/{run_uid}/continue
Continue a previously completed incremental sync run to fetch only new data.
`uid` is used for all the endpoints and Run manipulation.
The `id` is an internal identifier returned to smooth and improve speed and accuracy if you have questions about your runs you will want
to submit to the team.
## Prerequisites
The run must meet these conditions to be continued:
* The run was launched with `sync_mode: "incremental"` in the `parameters` object.
* The run was executed with an **Engagement Identity** (`type: "engagement"`).
* The run status is one of: `BLOCKED`, `STOPPED`, `FAILED`, `PARTIAL_SUCCEEDED`, or `SUCCEEDED`.
When a run is continued, its status and all related inputs are reset to **`SCHEDULED`**.
## Behavior
* Each continue call fetches up to `max_results` new items since the last retrieval.
* Results are delivered via the same callback URL configured during the original run.
* The run retains its original `run_uid` across all continuations.
If more new items were created than the `max_results` limit between two continue calls, items beyond that limit will be **lost**. Data is always fetched from the most recent to the oldest.
## Supported Actions
| Action | Description |
| -------------------------------------------------------------------------------------- | ------------------------------- |
| [`linkedin-extract-connections`](/v1/api/actions/linkedin-extract-connections) | Extract LinkedIn connections |
| [`linkedin-extract-messages`](/v1/api/actions/linkedin-extract-messages) | Extract LinkedIn messages |
| [`linkedin-extract-profile-viewers`](/v1/api/actions/linkedin-extract-profile-viewers) | Extract profile viewers |
| [`linkedin-extract-page-followers`](/v1/api/actions/linkedin-extract-page-followers) | Extract LinkedIn page followers |
For a full overview of incremental sync, see the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode).
# Get a Run
Source: https://docs.edges.run/v1/api/runs/get
v1/api/actions.json get /runs/{run_uid}
`uid` is used for all the endpoints and Run manipulation.
The `id` is an internal identifier returned to smooth and improve speed and accuracy if you have questions about your runs you will want
to submit to the team.
# Get Run Inputs
Source: https://docs.edges.run/v1/api/runs/inputs
v1/api/actions.json get /runs/{run_uid}/inputs
`uid` is used for all the endpoints and Run manipulation.
The `id` is an internal identifier returned to smooth and improve speed and accuracy if you have questions about your runs you will want
to submit to the team.
## Overview
The `GET /runs/{run_uid}/inputs` endpoint returns the complete list of inputs associated with a run, including their execution status and any associated errors. This endpoint is essential for recovering detailed input-level results and errors, especially when webhook callbacks are missed or need to be verified.
## Pagination
This endpoint uses **cursor-based pagination** by default. Follow the `X-Pagination-Next` response header to retrieve subsequent pages.
* `limit` controls the page size (default: **100**, max: **500**).
* The `X-Pagination-Next` header contains the **full URL** for the next page, including `limit` and `cursor`.
* When the `X-Pagination-Next` header is **absent**, there are no more pages.
The `offset` parameter is **deprecated**. If provided, the system falls back to offset-based pagination and cursor pagination is not used. Prefer following the `X-Pagination-Next` URL for all new integrations.
# List Runs
Source: https://docs.edges.run/v1/api/runs/list
v1/api/actions.json get /runs
`uid` is used for all the endpoints and Run manipulation.
The `id` is an internal identifier returned to smooth and improve speed and accuracy if you have questions about your runs you will want
to submit to the team.
# Resume a blocked Run
Source: https://docs.edges.run/v1/api/runs/manage
v1/api/actions.json post /runs/{run_uid}/resume
`uid` is used for all the endpoints and Run manipulation.
The `id` is an internal identifier returned to smooth and improve speed and accuracy if you have questions about your runs you will want
to submit to the team.
# Get Run Outputs
Source: https://docs.edges.run/v1/api/runs/outputs
v1/api/actions.json get /runs/{run_uid}/outputs
This endpoint is **not available** for runs executed in `live` mode. It only works for runs executed in `async` or `schedule` mode. For live mode runs, results are returned directly in the API response.
## Pagination
This endpoint uses **cursor-based pagination** by default. Follow the `X-Pagination-Next` response header to retrieve subsequent pages.
* `limit` controls the page size (default: **100**, max: **500**).
* The `X-Pagination-Next` header contains the **full URL** for the next page, including `limit` and `cursor`.
* When the `X-Pagination-Next` header is **absent**, there are no more pages.
```bash theme={null}
# First request
curl -X GET "https://api.edges.run/v1/runs/{run_uid}/outputs?limit=200" \
-H "Accept: application/json" \
-H "X-API-Key: "
# Follow X-Pagination-Next header for subsequent pages
curl -X GET "https://api.edges.run/v1/runs/{run_uid}/outputs?limit=200&cursor=" \
-H "Accept: application/json" \
-H "X-API-Key: "
```
The `offset` parameter is **deprecated**. If provided, the system falls back to offset-based pagination and cursor pagination is not used. Prefer following the `X-Pagination-Next` URL for all new integrations.
## Rate Limits
### Run's Routes Limits
To date, all /runs/xxx routes are subject to the same limit (e.g., 30 requests/minute for TRIAL plans). We are working to refine these quotas per endpoint (status, output, etc.) to better match usage patterns. Plans and limits will be updated in the documentation as soon as these changes take effect.
| Plan Tier | Max Requests/Second | Max Requests/Minute | Rationale |
| ------------------ | ------------------- | ------------------- | ------------------------------------------------------- |
| Trial | \< 1 | 30 | Supports 2 concurrent runs @ 10s polling interval |
| Bronze | 1 | 60 | Supports 2 concurrent runs with more aggressive polling |
| Silver / Gold | 2.5 | 150 | Supports 5 concurrent runs @ 10s polling interval |
| Platinum / Diamond | 5 | 300 | Supports 10 concurrent runs @ 10s polling interval |
| Titanium | 10 | 600 | Supports 15 concurrent runs @ 10s polling interval |
Rate limits for polling run results via `/v1/runs/{run_uid}/outputs`. These limits support realistic polling patterns for customers who prefer polling over callbacks.
These limits are aligned with concurrent execution limits. For example, with a Silver/Gold plan (5 concurrent runs), you can poll all active runs every 10 seconds with comfortable headroom.
#### Capacity Examples
| Plan Tier | Polling Capacity | Use Case |
| ------------------ | ---------------------------------------- | -------------------------------- |
| Trial | Poll 2 runs every 10s | Basic polling during development |
| Bronze | Poll 2 runs every 10s with headroom | Small-scale polling |
| Silver / Gold | Poll 5 runs every 10s, or 1 run every 4s | Team polling operations |
| Platinum / Diamond | Poll 10 runs every 10s | Multi-workspace polling |
| Titanium | Poll 15 runs every 10s | Enterprise-scale polling |
**Implementation Details:**
* Rate limit type: Per-workspace, per-minute
* Error response: Standard 429 with `X-RateLimit-Type: /v1/runs/outputs`
* Headers include `X-RateLimit-Remaining` for visibility
# Get Run Status
Source: https://docs.edges.run/v1/api/runs/status
v1/api/actions.json get /runs/{run_uid}/status
`uid` is used for all the endpoints and Run manipulation.
The `id` is an internal identifier returned to smooth and improve speed and accuracy if you have questions about your runs you will want
to submit to the team.
Use this endpoint to poll for run status without fetching full run details. This is useful for lightweight status checks in your automation workflows.
# Get a Schedule
Source: https://docs.edges.run/v1/api/schedules/get
v1/api/actions.json get /schedules/{scheduled_run_uid}
# List Schedules
Source: https://docs.edges.run/v1/api/schedules/list
v1/api/actions.json get /schedules
# Resume, Pause, or Cancel a Scheduled Run
Source: https://docs.edges.run/v1/api/schedules/manage
v1/api/actions.json post /schedules/{scheduled_run_uid}/{action}
# Credit Consumption
Source: https://docs.edges.run/v1/api/workspace/consumption
v1/api/actions.json get /workspaces/consumption
Retrieve credit usage for the current billing period
# Get a Workspace
Source: https://docs.edges.run/v1/api/workspace/get
v1/api/business.json get /workspaces
Get Workspace
# Core Concepts
Source: https://docs.edges.run/v1/core-concepts
Understand Identities, Integrations, and how Edges connects to LinkedIn.
**TL;DR:** Edges uses **Identities** (your users) connected to **Integrations** (LinkedIn accounts) to run **Actions**. That's it.
## How Edges Works
```
Your App → Identity → Integration (LinkedIn) → Action → Results
```
| Entity | What it is | Example |
| -------------------- | ---------------------------- | ------------------------------- |
| **Workspace Member** | Someone who logs into Edges | Your team, admins |
| **Identity** | An end user in *your* app | Your customer's account |
| **Integration** | A connected platform account | A LinkedIn profile |
| **Action** | An operation you execute | "Search People", "Send Message" |
***
## Identities vs. Workspace Members
Edges distinguishes between two types of users:
| | Workspace Member | Identity |
| -------------- | ----------------------------------------------------------------- | ------------------------------------------- |
| **Who** | Your team | Your end users |
| **Access** | Edges dashboard | None (API only) |
| **Purpose** | Manage settings, billing | Execute automated actions |
| **Example** | Admin, developer, ops | LinkedIn account for outreach |
| **How to add** | [Invite via Members page](https://app.edges.run/settings/members) | [Create via API](/v1/api/identities/create) |
### Workspace Member Roles
| Role | Permissions |
| --------- | ------------------------------------------------------- |
| **Admin** | Full access: Members, Identities, Integrations, Billing |
| **Ops** | Manage Identities & Integrations (no billing) |
| **User** | Read-only access |
### What is an Identity?
An **Identity** represents an end user in your SaaS or AI agent platform. Identities:
* Execute automated Actions on your behalf
* Connect to Integrations (like LinkedIn)
* Have no access to the Edges dashboard
* Are ideal for mapping your users to integration accounts
**When do you need Identities?** Only for actions that require being "logged in" — sending messages, accepting invitations, etc. For generic enrichment, use [Managed Mode](/v1/identities/modes#managed-mode) instead.
### Identity Modes
Control how accounts execute your Actions:
| Mode | Setup | Cost | Best for |
| --------- | ---------------- | ------------ | ------------------------ |
| `managed` | None | 1.5× credits | Getting started, testing |
| `direct` | Connect accounts | Standard | User-specific outreach |
| `auto` | Rent accounts | \$70-125/mo | High-volume operations |
See the [Quickstart](/v1/quickstart#identity-modes-explained) for code examples of each mode.
### Managing Identities
Use the [Create Identity API](/v1/api/identities/create) or the [Identities page](https://app.edges.run/identities).
Link a LinkedIn account via [Chrome Extension](/v1/linkedin/chrome-extension), [API authentication](/v1/api/linkedin/authentication), or [cookies](/v1/api/integrations/connect).
Use `identity_ids` in your API calls to specify which Identity runs the Action.
**Licensing:** Identity seats are included in your plan. Check [Pricing](https://edges.run/pricing) for your allocation. Contact [sales@edges.run](mailto:sales@edges.run) for higher limits.
### Identity Security
Every Identity is assigned a unique IP address for enhanced security. Learn more about [Identity management and security](/v1/identities/add-manage-identities).
***
## Integrations
An **Integration** connects an Identity to an external service (LinkedIn, Sales Navigator, etc.).
* Each Integration belongs to **one Identity**
* Integrations authenticate your requests with third-party APIs
* Multiple Integrations can connect to the same Identity (e.g., LinkedIn + Sales Navigator)
### LinkedIn Integrations
| Feature | Description |
| ---------------------- | ------------------------------------------------------ |
| **Smart Limits** | Edges auto-enforces safe usage to prevent restrictions |
| **Supported Licenses** | Sales Navigator, Premium, Recruiter Lite |
| **Account Rental** | Skip the hassle of warming up accounts |
How Edges protects your accounts
What's supported
Choose your approach
Avoid rate limits
### LinkedIn Webhooks
Get real-time notifications when account status changes:
| Event | When it fires |
| -------------- | ------------------------------ |
| `AUTH_SUCCESS` | Account connected successfully |
| `AUTH_PENDING` | Awaiting verification |
| `AUTH_FAILED` | Connection failed |
| `AUTH_EXPIRED` | Session expired |
| `AUTH_UPDATED` | Credentials refreshed |
Webhooks are essential for maintaining reliable integrations. See [setup instructions](/v1/identities/linkedin#monitor-linkedin-integration-status-with-webhooks).
***
## Execution Modes
Edges supports three ways to run Actions:
* **Response:** Immediate (synchronous)
* **Use case:** Single requests, real-time enrichment
* **Endpoint:** `/run/live`
```bash theme={null}
POST /v1/actions/linkedin-extract-people/run/live
```
Best for most use cases due to simplicity.
* **Response:** Run ID immediately, results via callback
* **Use case:** Batch processing, large datasets
* **Endpoint:** `/run/async`
```bash theme={null}
POST /v1/actions/linkedin-extract-people/run/async
```
Ideal when processing thousands of records or when real-time isn't required.
See [Async & Callbacks](/v1/runs/callbacks) for implementation details.
* **Response:** Schedule ID, results via callback on each run
* **Use case:** Recurring tasks, campaigns, off-peak processing
* **Endpoint:** `/run/schedule`
```bash theme={null}
POST /v1/actions/linkedin-extract-people/run/schedule
```
Define `schedule_at`, `cron`, and `timezone` for precise timing.
See [Schedules](/v1/runs/schedules) for CRON examples.
***
## Data Model
For developers building deep integrations, here's the database schema showing entity relationships:
![]()
**Interactive version:** [View full diagram](https://drawsql.app/teams/edges/diagrams/embed-edges-data-v1)
***
## What's next?
Create and manage your first Identity
Link a LinkedIn account to an Identity
Explore 60+ available Actions
Type-safe SDK for faster development
# Error Reference
Source: https://docs.edges.run/v1/error-reference
Complete reference for all error labels, HTTP status codes, and troubleshooting guidance for the Edges API.
This page provides a comprehensive reference for understanding and handling errors across the Edges API. Use the [Quick Reference Table](#quick-reference-table) for fast lookups, or dive into the detailed sections for specific error handling guidance.
**Two levels of reading**: Each action's documentation includes the specific errors it can return. This page provides the **overall error landscape** across all actions, helping you build robust error handling in your integrations.
***
## Quick Reference Table
| Error Label | HTTP Code | Category | Retry? |
| ----------------------------- | --------- | --------------- | ------------------------------------------------------- |
| `BAD_INPUT` | 400 | Input | No — fix input |
| `BAD_PARAMETERS` | 400 | Input | No — fix parameters |
| `MISSING_PARAMETER` | 424 | Input | No — add parameter |
| `NO_ACCESS` | 402 | Access | No — check subscription |
| `STATUS_403` | 424 | Access | No — check permissions |
| `STATUS_404` | 424 | Not Found | No — resource doesn't exist |
| `NO_RESULT` | 424 | Not Found | No — empty result |
| `LIMIT_REACHED` | 429/409 | Rate Limit | Yes - Use `postponed_until` then with backoff |
| `STATUS_429` | 429 | Rate Limit | Yes — Use `postponed_until` then with backoff |
| `LK_ERROR` | 424 | LinkedIn | No |
| `LK_524` | 424 | LinkedIn | Yes — wait & retry |
| `LK_MISSING_DATA` | 424 | LinkedIn | No |
| `LK_INMAIL_CANNOT_RESEND` | 424 | LinkedIn | No — wait for reply |
| `LK_INMAIL_NOT_ENOUGH_CREDIT` | 424 | LinkedIn | No — add credits |
| `LK_EVENT` | 424 | LinkedIn | No — check event |
| `NOT_CONNECTED` | 424 | LinkedIn | No — connect first |
| `SN_CONFLICT` | 424 | Sales Navigator | No — already connected |
| `SN_OUT_OF_NETWORK` | 424 | Sales Navigator | No — upgrade account |
| `NO_VALID_ACCOUNT_CONFIGURED` | 424 | Config | No — configure identity |
| `INTEGRATION_ERROR` | 424 | Config | No - contact support |
| `PROXY_ERROR` | 424 | Config | Yes — Use `postponed_until` if present or wait 1 minute |
| `GENERIC_ERROR` | 424 | Processing | No - contact support |
| `NO_DATA_LOADED` | 424 | Processing | No |
| `NO_DATA_AVAILABLE` | 424 | Processing | No — no data found for this input |
| `MANDATORY_DATA_MISSING` | 424 | Processing | No — check input |
| `UNDEFINED_FIELD` | 424 | Processing | No — check input |
| `UNKNOWN_ERROR` | 424 | System | Contact support |
| `ACTION_ABORTED` | 422 | System | No - Check `appendix` |
| `API_MAX_RETRY` | 424 | System | Conditional — yes if managed/auto |
| `API_TIMEOUT_ERROR` | 424 | System | Yes |
| `GMAPS_NO_INTERCEPT` | 424 | Input | No |
| `HPE_HEADER_OVERFLOW` | 424 | System | No |
| `HTTP_RESPONSE_EMPTY` | 424 | System | Depends — see insights |
| `LK_403` | 424 | LinkedIn | No |
| `LK_409` | 424 | LinkedIn | No |
| `LK_413` | 424 | LinkedIn | No |
| `LK_BAD_COOKIE` | 424 | LinkedIn | Yes if managed/auto — update integration |
| `LK_LOGIN_ERROR` | 424 | LinkedIn | Yes if managed/auto |
| `LR_ACCOUNT_UPGRADE` | 424 | LinkedIn | Yes if managed/auto |
| `MISSING_COOKIE` | 424 | Config | Yes if managed/auto |
| `RLS_BAD_COOKIE` | 424 | LinkedIn | Yes if managed/auto |
| `SN_ACCOUNT_UPGRADE` | 424 | Sales Navigator | Yes if managed/auto |
| `SN_LOGIN_ERROR` | 424 | Sales Navigator | Yes if managed/auto |
| `RLS_LOGIN_ERROR` | 424 | LinkedIn | Yes if managed/auto |
| `STATUS_400` | 400 | Input | No — API only |
| `STATUS_409` | 409 | System | No — API only |
| `STATUS_422` | 422 | System | No — API only |
| `HTTP_ERROR` | 424 | System | Yes |
| `LK_GET_FEATURES_ERROR` | 424 | LinkedIn | Yes if managed/auto |
| `LK_ACCOUNT_UPGRADE` | 424 | LinkedIn | Yes if managed/auto |
| `RUN_MAX_RETRY` | 424 | System | No — run async only; resume resets retry\_count |
| `OUTPUT_VALIDATION_FAILED` | 424 | Processing | No — contact support |
***
## Error Response Structure
The API uses a consistent error response format across all endpoints. When an error occurs, you'll receive a response with the following structure:
```json theme={null}
{
"error_label": "INVALID_INPUT",
"error_scope": "input",
"error_ref": "ERR-12345",
"message": "The provided input is invalid. Please check your request and try again.",
"status_code": 400,
"params": {}
}
```
Each error response includes:
* `error_label`: A machine-readable identifier for the error type
* `error_scope`: Indicates which part of the request caused the error (e.g., "input", "auth", "server")
* `error_ref`: A unique reference code for tracking and debugging
* `message`: A human-readable description of the error
* `status_code`: The HTTP status code
* `params`: Additional error parameters (if any)
Common HTTP status codes:
* `200`: The request was successful (some API calls may return 201 instead)
* `400`: Bad Request - Invalid input or parameters
* `401`: Unauthorized - Invalid or missing API key
* `403`: Forbidden - Insufficient permissions
* `404`: Not Found - Resource doesn't exist
* `424`: Failed Dependency - Used to wrap LinkedIn-specific error codes with an additional `error_label`
* `500`: Internal Server Error - Server-side issue
**Why we use 424 for LinkedIn errors**: We use the `424 Failed Dependency` status code to wrap all LinkedIn-specific error codes. This is because a 404 (or any other error code) from LinkedIn doesn't imply the same error code on our own APIs. For example, if LinkedIn returns a 404 for a profile that doesn't exist, that doesn't mean our API endpoint is returning a 404 — it means the dependency (LinkedIn) failed. The specific LinkedIn error is indicated in the `error_label` field (e.g., `STATUS_404`, `NO_RESULT`, etc.).
Always check the `error_label` and `error_scope` fields to programmatically
handle different types of errors in your application.
If you encounter an unusual error, such as a 500 or 503, feel free to reach
out! These are internal errors on our end, and we're happy to help resolve
them.
***
## Understanding Error Scopes
Every error response includes an `error_scope` field that indicates what caused the error:
| Scope | Description | Typical Action |
| -------- | ------------------------------------------- | ------------------------------------------ |
| `input` | The input data provided is invalid | Fix the input format or value |
| `param` | A parameter in the request is invalid | Check parameter requirements |
| `config` | Configuration issue (identity, integration) | Verify your setup in the dashboard |
| `integ` | Third-party integration error (LinkedIn) | Check resource availability or retry later |
The `retry_after` field from tier provides guidance on how long to wait before making your first retry attempt. For subsequent retries, use an exponential backoff strategy by increasing the wait time between each attempt.
***
## Handling Rate Limit Errors (429)
`429` errors indicate that you've exceeded a rate limit imposed by either Edges or LinkedIn. It's crucial to identify the source of the limit to apply the appropriate handling strategy.
A `429 Too Many Requests` error means you've exceeded a usage limit — but it's important to identify **which system** triggered it.
| Source | Identifier | Retry Strategy |
| ------------------ | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Edges API | `X-RateLimit-Type` header | Use `Retry-After` header + exponential backoff |
| LinkedIn (guarded) | `error_label = LIMIT_REACHED` | Check **`params.appendix`** and **`params.timespan`** to distinguish limit type (e.g. `API_FUSE_LIMIT`/Daily, `MINUTE_LIMIT`/Minute). Wait for the relevant window to reset. |
| LinkedIn (raw) | `error_label = STATUS_429` | Apply exponential backoff. Do not retry aggressively. |
**Example Implementation**:
```javascript theme={null}
if (error.status === 429) {
if (error.headers['x-ratelimit-type']) {
// Edges rate limit - use Retry-After header
const delay = error.headers['retry-after'] * 1000;
await new Promise(resolve => setTimeout(resolve, delay));
} else if (error.body.error_label === 'LIMIT_REACHED') {
// Check params.appendix (e.g. API_FUSE_LIMIT, API_RATE_LIMIT, MINUTE_LIMIT, DAILY_LIMIT) and params.timespan
const appendix = error.body.params?.appendix;
const timespan = error.body.params?.timespan;
console.log('Limit reached:', appendix, timespan);
} else if (error.body.error_label === 'STATUS_429') {
// LinkedIn raw - exponential backoff
const delay = Math.min(1000 * Math.pow(2, retryCount), 30000);
await new Promise(resolve => setTimeout(resolve, delay));
}
}
```
**General Recommendations**:
* Monitor identity usage via `/identities/{identity_uid}/actions/{action_slug}/limits`
* Avoid parallel tools or conflicting automation platforms
* Match identity timezones with VPNs and login locations
To know more about rate limits, see our dedicated [Rate Limits](/v1/runs/rate-limits) section and [best practices](/v1/runs/rate-limits#best-practices).
***
## Handling LinkedIn Errors (424)
`424` errors indicate a failed dependency — we use this status code to wrap all LinkedIn-specific error codes. It's important to identify the specific `error_label` to determine the appropriate handling strategy.
A `424 Failed Dependency` error means the external service (LinkedIn) returned an error — the `error_label` will tell you **which LinkedIn error** occurred.
**Why we use 424 for LinkedIn errors**: We use the `424 Failed Dependency` status code to wrap all LinkedIn-specific error codes. This is because a 404 (or any other error code) from LinkedIn doesn't imply the same error code on our own APIs. For example, if LinkedIn returns a 404 for a profile that doesn't exist, that doesn't mean our API endpoint is returning a 404 — it means the dependency (LinkedIn) failed. The specific LinkedIn error is indicated in the `error_label` field (e.g., `STATUS_404`, `NO_RESULT`, etc.).
**Example Implementation**:
```javascript theme={null}
if (error.status === 424) {
const label = error.body.error_label;
switch (label) {
case 'STATUS_404':
// Resource doesn't exist - don't retry
console.log('Resource not found on LinkedIn:', error.body.message);
break;
case 'NO_RESULT':
// No results found - treat as empty result
console.log('No results found:', error.body.message);
break;
case 'LK_ERROR':
case 'GENERIC_ERROR':
// Transient error - retry with backoff
const delay = Math.min(1000 * Math.pow(2, retryCount), 30000);
await new Promise(resolve => setTimeout(resolve, delay));
break;
case 'LIMIT_REACHED':
// LinkedIn limit - wait for reset
console.log('Limit reached, waiting for reset...');
break;
default:
console.log('Unhandled error:', label, error.body.message);
}
}
```
# FAQ
Source: https://docs.edges.run/v1/faq
Answers to frequently asked questions about the Edges API, including data retention, billing, and common usage questions.
## How long is run data kept?
Edges automatically archives run data after **90 days** to maintain optimal platform performance. Once archived, runs are no longer accessible via the API.
**Retention periods:**
* **Runs and Flow Runs**: 90 days
* **Usage Records**: 5 days
* **Output Statistics**: 90 days
If you need to keep run data longer than 90 days, make sure to store results in your own system via callbacks or export important data before the retention period expires.
Outputs are **not available** for runs executed in `live` mode. It only works for runs executed in `async` or `schedule` mode. For live mode runs, results are returned directly in the API response.
For more details, see the [Data Retention section](/v1/runs/manage#data-retention) in the Managing Runs guide.
***
## How to track credits consumption?
To monitor your workspace's credit consumption, you can use the [Credit Consumption](/v1/api/workspace/consumption) endpoint.
This endpoint provides detailed information about the credits used during the current billing period, grouped by action.
It takes no parameters (always returns current billing period usage) and returns a breakdown of credit usage, allowing you to track your workspace consumption effectively.
Example response:
```json theme={null}
{
"credits_left": 16689.1,
"credits_used": 3310.9,
"credits_max": 20000,
"current_month_start": "2025-10-14T07:13:47.000Z",
"current_month_end": "2025-11-14T07:13:47.000Z",
"consumptions": [
{
"action_slug": "linkedin-extract-people",
"credits_used": 112
},
// ... truncated for brevity ...
{
"action_slug": "linkedin-connect-profile",
"credits_used": 90
}
]
}
```
It retrieves only data for actions that have been used in the current billing period (don't forget **decimal values are possible**).
***
## Troubleshooting & Errors
For comprehensive error handling guidance, including:
* Error response structure and scopes
* Quick reference table of all error labels
* Handling 429 (rate limit) and 424 (LinkedIn) errors
* Detailed documentation for each error type
Complete guide to understanding and handling all API errors
***
## Rate Limits
For information about rate limits and best practices:
Edges API request limits by plan tier
How Edges protects LinkedIn accounts from restrictions
# Migrate to Incremental Mode
Source: https://docs.edges.run/v1/guides/incremental-mode
Implement incremental sync for Extract LinkedIn Connections with Engagement Identities, and migrate existing full-mode schedules to incremental.
This guide shows how to use the **scheduled run endpoint** for [Extract LinkedIn Connections](/v1/api/actions/linkedin-extract-connections-schedule) with **incremental sync** via Engagement Identities, and how to migrate existing schedules to incremental mode using the `/actions/linkedin-extract-connections/run/schedule` route.
Incremental mode fetches **only new data** since the last retrieval instead of the full dataset on every run. It is available only on some [engagement-free actions](/v1/identities/engagement#included-actions) and requires an Engagement Identity.
More information here : [Incremental Sync Guide](https://docs.edges.run/v1/runs/overview#incremental-sync-mode)
***
## Prerequisites
* [Engagement Identities](/v1/identities/engagement) enabled in your workspace and at least one Engagement Identity created with a connected LinkedIn account
* API key with access to runs, schedules, and identities
***
## Shared setup (reuse in your code)
The examples below use a single base URL and a small request helper so headers and error handling stay consistent. Define these once and reuse them across Part 1 and Part 2.
```javascript theme={null}
const EDGES_API_BASE = 'https://api.edges.run/v1';
async function edgesRequest(apiKey, url, { method = 'GET', body } = {}) {
const res = await fetch(url, {
method,
headers: { 'X-API-Key': apiKey, 'Content-Type': 'application/json' },
...(body != null && { body: JSON.stringify(body) }),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
throw new Error(err.message ?? `Request failed: ${res.status}`);
}
return res.json();
}
```
***
## Part 1: Implementing Incremental Mode
### 1.1 Create a new scheduled run in incremental mode
To schedule **Extract LinkedIn Connections** in incremental mode, send `sync_mode: "incremental"` in the `parameters` object and use an Engagement Identity in `identity_ids`.
**Behavior:**
* **First run:** Full sync (capped by `max_results`).
* **Next runs:** Only new connections since the last run. No need to call continue; each scheduled execution is automatically incremental.
In schedule mode, if the previous run is still in progress when the next iteration is due, that iteration is **skipped**. The following one will run the incremental update.
**JavaScript example: create a scheduled incremental Extract Connections run**
```javascript theme={null}
// Uses EDGES_API_BASE and edgesRequest from the shared setup above.
async function createIncrementalExtractConnectionsSchedule(apiKey, options) {
const {
identityId,
linkedinUrl,
callbackUrl,
cron = '0 9 * * *', // daily at 9am
timezone = 'Europe/Paris',
maxResults,
} = options;
return edgesRequest(apiKey, `${EDGES_API_BASE}/actions/linkedin-extract-connections/run/schedule`, {
method: 'POST',
body: {
inputs: [{ linkedin_url: linkedinUrl }],
callback: { url: callbackUrl },
identity_ids: [identityId],
cron,
timezone,
parameters: {
sync_mode: 'incremental',
...(maxResults != null && { max_results: maxResults }),
},
},
});
}
// Usage: ensure identityId is an Engagement Identity (type === 'engagement')
// const schedule = await createIncrementalExtractConnectionsSchedule(process.env.EDGES_API_KEY, {
// identityId: 'id_xxx',
// linkedinUrl: 'https://linkedin.com/in/johndoe',
// callbackUrl: 'https://yourdomain.com/webhooks/edges',
// });
```
### 1.2 Async mode: continue an incremental run
If you use **async** instead of schedule, you trigger each incremental update by calling the continue endpoint after the previous run has finished.
**JavaScript example: run async and continue later (Extract Connections)**
```javascript theme={null}
// Uses EDGES_API_BASE and edgesRequest from the shared setup above.
async function runExtractConnectionsIncrementalAsync(apiKey, options) {
return edgesRequest(apiKey, `${EDGES_API_BASE}/actions/linkedin-extract-connections/run/async`, {
method: 'POST',
body: {
inputs: [{ linkedin_url: options.linkedinUrl }],
callback: { url: options.callbackUrl },
identity_ids: [options.identityId],
parameters: {
sync_mode: 'incremental',
...(options.maxResults != null && { max_results: options.maxResults }),
},
},
});
}
async function continueIncrementalRun(apiKey, runUid) {
return edgesRequest(apiKey, `${EDGES_API_BASE}/runs/${runUid}/continue`, { method: 'POST' });
}
```
***
## Part 2: Migrating full-mode schedules to incremental
Schedules cannot be updated in place (e.g. to add `parameters.sync_mode`). To switch existing **Extract Connections** schedules from full to incremental, you must:
1. List schedules for `linkedin-extract-connections` (optionally restricted to Engagement Identities).
2. For each schedule: get full details, cancel it, then create a new schedule with the same config plus `parameters.sync_mode: "incremental"`.
Use only **Engagement Identities** for the new schedules; incremental sync is not supported for standard identities.
Schedule objects in the examples have optional fields such as `scheduled_run_uid`, `uid`, `identity_ids`, `inputs`, `callback`, `cron`, `timezone`, `parameters`, `max_results`.
### 2.1 Get Engagement Identity IDs
Filter identities with `type: "engagement"` so you only migrate schedules that use them (or only recreate schedules using those identities). The helper below paginates so all identities are returned (not only the first 100).
```javascript theme={null}
// Uses EDGES_API_BASE and edgesRequest from the shared setup above.
async function getEngagementIdentityIds(apiKey) {
const ids = [];
let offset = 0;
const limit = 100;
let hasMore = true;
while (hasMore) {
const data = await edgesRequest(
apiKey,
`${EDGES_API_BASE}/identities?limit=${limit}&offset=${offset}`
);
const items = data.data ?? data.items ?? (Array.isArray(data) ? data : []);
ids.push(...items.filter((id) => id.type === 'engagement').map((id) => id.uid));
hasMore = items.length === limit;
offset += limit;
}
return ids;
}
```
### 2.2 List Extract Connections schedules (full mode)
List schedules for the Extract Connections action. The helper paginates so all matching schedules are returned.
```javascript theme={null}
// Uses EDGES_API_BASE and edgesRequest from the shared setup above.
async function listExtractConnectionsSchedules(apiKey) {
const schedules = [];
let offset = 0;
const limit = 100;
let hasMore = true;
while (hasMore) {
const params = new URLSearchParams({
action_name: 'linkedin-extract-connections',
status: 'ACTIVE',
limit: String(limit),
offset: String(offset),
});
const data = await edgesRequest(apiKey, `${EDGES_API_BASE}/schedules?${params}`);
const items = data.data ?? data.items ?? (Array.isArray(data) ? data : []);
schedules.push(...items);
hasMore = items.length === limit;
offset += limit;
}
return schedules;
}
```
### 2.3 Filter by Engagement Identity (optional)
If the list response includes `identity_ids` (or similar), keep only schedules whose identities are in your set of Engagement Identity UIDs. If the API does not return identity info, you can still migrate all Extract Connections schedules and rely on the fact that the **new** schedule you create will use an Engagement Identity.
```javascript theme={null}
function filterSchedulesByEngagementIdentities(schedules, engagementIdentityIds) {
const set = new Set(engagementIdentityIds);
return schedules.filter((s) => {
const ids = s.identity_ids ?? [];
return ids.some((id) => set.has(id));
});
}
```
### 2.4 Cancel and recreate each schedule with incremental mode
For each schedule to migrate:
1. **GET** the schedule by `scheduled_run_uid` to get `inputs`, `callback`, `cron`, `timezone`, `identity_ids`, etc.
2. **POST** `.../schedules/{scheduled_run_uid}/cancel` to delete it.
3. **POST** `.../actions/linkedin-extract-connections/run/schedule` with the same config plus `parameters: { sync_mode: 'incremental' }`.
Migration helpers (use `edgesRequest` from the shared setup):
```javascript theme={null}
async function getSchedule(apiKey, scheduledRunUid) {
return edgesRequest(apiKey, `${EDGES_API_BASE}/schedules/${scheduledRunUid}`);
}
async function cancelSchedule(apiKey, scheduledRunUid) {
return edgesRequest(apiKey, `${EDGES_API_BASE}/schedules/${scheduledRunUid}/cancel`, {
method: 'POST',
});
}
async function migrateScheduleToIncremental(apiKey, scheduledRunUid) {
const schedule = await getSchedule(apiKey, scheduledRunUid);
await cancelSchedule(apiKey, scheduledRunUid);
const body = {
inputs: schedule.inputs ?? [],
callback: schedule.callback ?? {},
identity_ids: schedule.identity_ids ?? [],
...(schedule.cron && { cron: schedule.cron }),
...(schedule.timezone && { timezone: schedule.timezone }),
...(schedule.schedule_at && { schedule_at: schedule.schedule_at }),
parameters: {
// Add parameters if needed manually, because you can't get back parameters from scheduled runs
sync_mode: 'incremental',
},
// Add max_results if needed manually
};
return edgesRequest(apiKey, `${EDGES_API_BASE}/actions/linkedin-extract-connections/run/schedule`, {
method: 'POST',
body,
});
}
```
If you don't need to get older results with the first incremental mode. Keep the max\_results low to avoid time consumption
### 2.5 Full migration script (Extract Connections + Engagement Identities)
End-to-end example: list active Extract Connections schedules, restrict to those using Engagement Identities, then migrate each to incremental by cancel + recreate. Runs **sequentially** to avoid rate limits.
```javascript theme={null}
// Uses EDGES_API_BASE, edgesRequest, and all helpers above.
async function migrateExtractConnectionsSchedulesToIncremental(apiKey) {
const engagementIds = await getEngagementIdentityIds(apiKey);
if (engagementIds.length === 0) {
console.warn('No Engagement Identities found. Incremental mode requires them.');
return [];
}
const schedules = await listExtractConnectionsSchedules(apiKey);
const toMigrate = filterSchedulesByEngagementIdentities(schedules, engagementIds);
const results = [];
for (const s of toMigrate) {
const uid = s.scheduled_run_uid ?? s.uid;
if (!uid) continue;
try {
const newSchedule = await migrateScheduleToIncremental(apiKey, uid);
results.push({ uid, newSchedule });
console.log(`Migrated schedule ${uid}`);
} catch (e) {
const message = e instanceof Error ? e.message : String(e);
results.push({ uid, error: message });
console.error(`Failed to migrate ${uid}:`, message);
}
}
return results;
}
// Run migration
migrateExtractConnectionsSchedulesToIncremental(process.env.EDGES_API_KEY)
.then((results) => console.log('Migration results:', results))
.catch((err) => console.error('Migration failed:', err));
```
***
## Summary
| Goal | Approach |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **New incremental schedule** | `POST /v1/actions/linkedin-extract-connections/run/schedule` with `parameters.sync_mode: "incremental"` and an Engagement Identity in `identity_ids`. |
| **Async incremental** | Same `parameters` on async run; then call `POST /v1/runs/{run_uid}/continue` for each subsequent fetch. |
| **Existing full-mode schedules → incremental** | List schedules (`GET /v1/schedules?action_name=linkedin-extract-connections`), filter by Engagement Identity if needed, then for each: GET schedule → cancel → recreate with `sync_mode: "incremental"`. |
For more on incremental sync behavior and limits, see the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode) and [Continue a run](/v1/api/runs/continue).
# Build a LinkedIn Outreach Sequence
Source: https://docs.edges.run/v1/guides/linkedin-outreach-sequence
Complete guide to building automated LinkedIn outreach sequences with de-duplication, error handling, and production-ready patterns.
This guide walks you through building a production-ready LinkedIn outreach sequence using the Edges API. You'll learn how to:
* Set up identities and connect LinkedIn accounts
* Source and manage leads
* Send connection requests and messages at scale
* Handle replies, de-duplication, and errors
* Respect rate limits and best practices
**Recommended setup:** Use [Engagement Identities](/v1/identities/engagement) for outreach actions. They're credit-free for connection requests, messages, and profile visits.
***
## Section 1: Prerequisites & Key Concepts
Before building your sequence, familiarize yourself with these core concepts:
| Concept | What it is | Documentation |
| ----------------------- | --------------------------------------------------------------------- | --------------------------------------------------------------- |
| **Workspace** | Isolated environment with its own API key and identities | [Core Concepts](/v1/core-concepts) |
| **Identity** | Represents a user whose LinkedIn account will perform actions | [Add & Manage Identities](/v1/identities/add-manage-identities) |
| **Engagement Identity** | Special identity type with credit-free outreach actions | [Engagement Identities](/v1/identities/engagement) |
| **Identity Modes** | `direct`, `auto`, `managed` - controls which account performs actions | [Identity Modes](/v1/identities/modes) |
| **Smart Limits** | Per-action, per-identity daily limits to protect accounts | [LinkedIn Smart Limits](/v1/linkedin/limits) |
| **Execution Modes** | `live` (sync), `async` (background), `schedule` (recurring) | [Execute Actions](/v1/runs/overview) |
| **Callbacks** | Webhook delivery for async/scheduled action results | [Callbacks](/v1/runs/callbacks) |
### Identity Setup Checklist
Use the [Create Identity API](/v1/api/identities/create) with `is_engagement: true`
Use [Connect Integration](/v1/api/integrations/connect) with cookies, email/password, or login links
Monitor integration status changes like `AUTH_EXPIRED`. See [LinkedIn Integration Webhooks](/v1/identities/linkedin#monitor-linkedin-integration-status-with-webhooks)
***
## Section 2: Lead Sourcing
Leads can come from Edges search actions or external sources like CSV uploads.
### Option A: Edges Search
```javascript JavaScript theme={null}
// Search for leads using LinkedIn search
// 1. Build your search URL on LinkedIn first (e.g., filter by title, location, company)
// 2. Copy the search URL from your browser
const searchUrl = 'https://www.linkedin.com/search/results/people/?keywords=CTO&geoUrn=%5B103644278%5D&origin=FACETED_SEARCH';
const searchResults = await fetch('https://api.edges.run/v1/actions/linkedin-search-people/run/live', {
method: 'POST',
headers: {
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
body: JSON.stringify({
identity_mode: 'auto',
input: {
linkedin_people_search_url: searchUrl
}
})
});
const leads = await searchResults.json();
// Each result contains: linkedin_profile_url, full_name, headline, etc.
```
```python Python theme={null}
import requests
# Search for leads using LinkedIn search
# 1. Build your search URL on LinkedIn first (e.g., filter by title, location, company)
# 2. Copy the search URL from your browser
search_url = 'https://www.linkedin.com/search/results/people/?keywords=CTO&geoUrn=%5B103644278%5D&origin=FACETED_SEARCH'
response = requests.post(
'https://api.edges.run/v1/actions/linkedin-search-people/run/live',
headers={
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
json={
'identity_mode': 'auto',
'input': {
'linkedin_people_search_url': search_url
}
}
)
leads = response.json()
# Each result contains: linkedin_profile_url, full_name, headline, etc.
```
**How it works:** Build your search filters on LinkedIn (title, location, company, etc.), then copy the search URL and pass it to the API. See [Search LinkedIn People](/v1/api/actions/linkedin-search-people) for details.
**Have Sales Navigator?** Use [salesnavigator-search-people](/v1/api/actions/salesnavigator-search-people) instead for access to advanced filters (seniority, function, company headcount growth, etc.). Works the same way — build your search on LinkedIn Sales Navigator and pass the URL.
### Option B: External Sources
Import leads from your CRM, CSV, or other sources. Required fields:
* `linkedin_profile_url` (required) - e.g., `https://www.linkedin.com/in/johndoe`
* `full_name` (recommended for personalization)
* `company_name` (recommended for personalization)
**Best practice:** Store the immutable `linkedin_profile_id` once you have it. Profile URLs can change if users update their vanity URL.
***
## Section 3: Get User's LinkedIn Profile ID
The user's `linkedin_profile_id` is needed to detect replies (comparing who sent the last message).
**Good news:** The `linkedin_profile_id` is already available in the integration's `meta` field when you retrieve the integration details. No extra API call needed!
```javascript JavaScript theme={null}
// Get linkedin_profile_id from integration meta (recommended)
async function getIntegrationProfileId(identityId, integration = 'linkedin') {
const response = await fetch(
`https://api.edges.run/v1/identities/${identityId}/integrations/${integration}`,
{
headers: { 'X-API-Key': EDGES_API_KEY }
}
);
const data = await response.json();
return data.meta?.linkedin_profile_id; // Already available!
}
// Cache this when identity is created/connected
const userProfileId = await getIntegrationProfileId('identity_abc123');
```
```python Python theme={null}
import requests
def get_integration_profile_id(identity_id: str, integration: str = 'linkedin') -> int:
"""Get linkedin_profile_id from integration meta (recommended)."""
response = requests.get(
f'https://api.edges.run/v1/identities/{identity_id}/integrations/{integration}',
headers={'X-API-Key': EDGES_API_KEY}
)
data = response.json()
return data.get('meta', {}).get('linkedin_profile_id') # Already available!
# Cache this when identity is created/connected
user_profile_id = get_integration_profile_id('identity_abc123')
```
See [Get an Identity's Integration](/v1/api/integrations/get) for full response schema.
**Alternative:** If you need additional profile details (headline, company, etc.), you can use [linkedin-me](/v1/api/actions/linkedin-me) which returns full profile information.
***
## Section 4: Database Schema (Pseudocode)
Track leads, conversations, and outreach history:
```sql theme={null}
-- Leads table
CREATE TABLE leads (
id UUID PRIMARY KEY,
identity_id VARCHAR NOT NULL, -- Which identity owns this lead
linkedin_profile_url VARCHAR NOT NULL,
linkedin_profile_id BIGINT, -- Immutable ID (populate when known)
full_name VARCHAR,
company_name VARCHAR,
location VARCHAR, -- For timezone/business hours
-- Sequence state
sequence_status VARCHAR DEFAULT 'NEW', -- NEW, IN_SEQUENCE, PAUSED, REPLIED, ARCHIVED
current_step INT DEFAULT 0,
next_action_at TIMESTAMP,
-- Connection state
connection_status VARCHAR DEFAULT 'NOT_CONNECTED', -- NOT_CONNECTED, PENDING, CONNECTED
connection_sent_at TIMESTAMP,
-- Tracking
last_contacted_at TIMESTAMP,
replied_at TIMESTAMP,
paused_reason VARCHAR,
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
);
-- Conversations cache (sync from extract-conversations)
CREATE TABLE conversations (
id UUID PRIMARY KEY,
identity_id VARCHAR NOT NULL,
linkedin_thread_id VARCHAR NOT NULL UNIQUE,
participant_profile_id BIGINT,
last_message_sender_id BIGINT,
last_message_at TIMESTAMP,
synced_at TIMESTAMP DEFAULT NOW()
);
-- Outreach log (audit trail)
CREATE TABLE outreach_log (
id UUID PRIMARY KEY,
lead_id UUID REFERENCES leads(id),
action_type VARCHAR NOT NULL, -- 'VISIT', 'CONNECT', 'MESSAGE', etc.
step_number INT,
status VARCHAR, -- 'SUCCESS', 'FAILED', 'SKIPPED'
error_label VARCHAR, -- e.g., 'LIMIT_REACHED', 'NOT_CONNECTED'
edges_run_id VARCHAR,
created_at TIMESTAMP DEFAULT NOW()
);
-- Indexes
CREATE INDEX idx_leads_next_action ON leads(identity_id, sequence_status, next_action_at);
CREATE INDEX idx_conversations_participant ON conversations(identity_id, participant_profile_id);
```
***
## Section 5: Lead Lifecycle State Machine
Visualize how leads progress through your sequence:
### Part A: Main Outreach Flow
The happy path from new lead to reply:
```mermaid theme={null}
stateDiagram-v2
[*] --> New: Lead added
New --> InSequence: Start sequence
InSequence --> PendingConnection: Connect sent
PendingConnection --> Connected: Accepted
Connected --> ReadyToMessage: Wait 3 days
ReadyToMessage --> WaitingReply: Message sent
WaitingReply --> FollowUp1: 7 days, no reply
FollowUp1 --> WaitingReply: Follow-up sent
WaitingReply --> FollowUp2: 7 more days
FollowUp2 --> WaitingReply: Follow-up 2 sent
WaitingReply --> Replied: Lead responds
WaitingReply --> Archived: No response
Replied --> [*]: Human takes over
Archived --> [*]: Sequence ended
```
### Part B: Edge Cases (Already Connected / Existing Conversation)
Handle leads who are already in your network or have messaged first:
```mermaid theme={null}
stateDiagram-v2
[*] --> New: Lead added
New --> CheckConnection: Check if connected
CheckConnection --> AlreadyConnected: Is connected
CheckConnection --> InSequence: Not connected
New --> LeadMessagedFirst: Has existing conversation
LeadMessagedFirst --> Replied: Human takes over
AlreadyConnected --> ReadyToMessage: No recent messages
AlreadyConnected --> WaitCooldown: Messaged in last 3 days
WaitCooldown --> ReadyToMessage: Cooldown passed
ReadyToMessage --> WaitingReply: Message sent
```
### Part C: Identity Failure Recovery
When LinkedIn auth expires, pause affected leads and resume when fixed:
```mermaid theme={null}
stateDiagram-v2
WaitingReply --> Paused: AUTH_EXPIRED
PendingConnection --> Paused: AUTH_EXPIRED
ReadyToMessage --> Paused: AUTH_EXPIRED
Paused --> WaitingReply: Identity restored
Paused --> ReadyToMessage: Identity restored
Paused --> PendingConnection: Identity restored
```
### Edge Cases Summary
| Scenario | Detection | Action |
| ------------------------------ | -------------------------------------------- | ---------------------------------- |
| **Lead already connected** | `extract-connections` contains lead | Skip connect, go to ReadyToMessage |
| **Recent conversation exists** | `last_message` within 3 days | Wait for cooldown before messaging |
| **Lead messaged first** | `extract-conversations` shows lead initiated | Mark as REPLIED, human takes over |
| **Identity auth expired** | Webhook `AUTH_EXPIRED` event | PAUSE all leads for that identity |
***
## Section 6: Action Limits Quick Reference
Each action in the sequence has specific daily limits. Link to the action doc for full response schema.
| Step | Action | Limit (Classic / Sales Nav) | Action Doc |
| --------------------- | -------------------------------- | --------------------------- | -------------------------------------------------------- |
| Visit | `linkedin-visit-profile` | 80 / 500 per day | [View →](/v1/api/actions/linkedin-visit-profile) |
| Connect | `linkedin-connect-profile` | 25 / 30 per day | [View →](/v1/api/actions/linkedin-connect-profile) |
| Message | `linkedin-message-profile` | 50 / 250 per day | [View →](/v1/api/actions/linkedin-message-profile) |
| InMail | `linkedin-inmail-profile` | Based on subscription | [View →](/v1/api/actions/linkedin-inmail-profile) |
| Extract Conversations | `linkedin-extract-conversations` | Free with Engagement | [View →](/v1/api/actions/linkedin-extract-conversations) |
| Extract Connections | `linkedin-extract-connections` | 30,000 per day | [View →](/v1/api/actions/linkedin-extract-connections) |
**Connection notes limit:** LinkedIn Classic accounts can only send **5 connection requests WITH a personalized note per month**. After that, notes are silently dropped. Consider: connect without note, then message after they accept.
**Full limits reference:** [LinkedIn Smart Limits →](/v1/linkedin/limits)
***
## Section 7: Error Labels for Outreach Actions
Each action returns specific error labels. Handle these in your code.
| Error Label | Actions Affected | Meaning | How to Handle |
| ------------------------ | ----------------- | ---------------------------------------- | ---------------------------------------------------------------- |
| `LIMIT_REACHED` | All | Daily Smart Limit hit | Schedule retry for tomorrow, use `postponed_until` from response |
| `NOT_CONNECTED` | `message-profile` | Can't message non-connection | Send connection request first |
| `ALREADY_CONNECTED` | `connect-profile` | Already 1st degree connection | Skip to message step |
| `INVITATION_PENDING` | `connect-profile` | Connection request already sent | Wait for accept or withdraw |
| `PROFILE_NOT_ACCESSIBLE` | All | Profile deleted, blocked, or URL changed | Remove from sequence or re-enrich |
| `AUTH_EXPIRED` | All | Identity LinkedIn session expired | Pause sequence, trigger re-auth webhook |
| `INVALID_INPUT` | All | Bad parameters (wrong URL format, etc.) | Fix input, check against action docs |
| `STATUS_429` | All | LinkedIn raw rate limit (not guarded) | Exponential backoff, wait and retry |
**How to handle in code:**
```javascript JavaScript theme={null}
async function executeWithErrorHandling(identityId, lead, actionFn) {
try {
const result = await actionFn();
return { success: true, result };
} catch (error) {
const errorLabel = error.error_label || 'UNKNOWN';
switch (errorLabel) {
case 'LIMIT_REACHED':
// Retry tomorrow - use postponed_until if available
const retryAt = error.postponed_until || tomorrow();
await updateLead(lead.id, { next_action_at: retryAt });
break;
case 'ALREADY_CONNECTED':
// Skip connect step, go to message
await updateLead(lead.id, {
connection_status: 'CONNECTED',
current_step: 3 // Skip to message step
});
break;
case 'INVITATION_PENDING':
// Already sent, just wait
await updateLead(lead.id, { connection_status: 'PENDING' });
break;
case 'NOT_CONNECTED':
// Can't message - need to connect first
await updateLead(lead.id, { current_step: 1 }); // Go to connect step
break;
case 'PROFILE_NOT_ACCESSIBLE':
// Remove from sequence
await updateLead(lead.id, {
sequence_status: 'ARCHIVED',
paused_reason: 'PROFILE_INACCESSIBLE'
});
break;
case 'AUTH_EXPIRED':
// Pause all leads for this identity
await pauseIdentityLeads(identityId, 'AUTH_EXPIRED');
break;
default:
// Log and investigate
console.error('Unexpected error:', error);
await logOutreachError(lead.id, error);
}
return { success: false, errorLabel };
}
}
function tomorrow() {
const date = new Date();
date.setDate(date.getDate() + 1);
date.setHours(9, 0, 0, 0); // 9am tomorrow
return date.toISOString();
}
```
```python Python theme={null}
from datetime import datetime, timedelta
async def execute_with_error_handling(identity_id: str, lead, action_fn):
try:
result = await action_fn()
return {'success': True, 'result': result}
except EdgesError as error:
error_label = getattr(error, 'error_label', 'UNKNOWN')
if error_label == 'LIMIT_REACHED':
# Retry tomorrow - use postponed_until if available
retry_at = getattr(error, 'postponed_until', None) or tomorrow()
await update_lead(lead.id, next_action_at=retry_at)
elif error_label == 'ALREADY_CONNECTED':
# Skip connect step, go to message
await update_lead(lead.id, connection_status='CONNECTED', current_step=3)
elif error_label == 'INVITATION_PENDING':
# Already sent, just wait
await update_lead(lead.id, connection_status='PENDING')
elif error_label == 'NOT_CONNECTED':
# Can't message - need to connect first
await update_lead(lead.id, current_step=1)
elif error_label == 'PROFILE_NOT_ACCESSIBLE':
# Remove from sequence
await update_lead(lead.id,
sequence_status='ARCHIVED',
paused_reason='PROFILE_INACCESSIBLE'
)
elif error_label == 'AUTH_EXPIRED':
# Pause all leads for this identity
await pause_identity_leads(identity_id, 'AUTH_EXPIRED')
else:
# Log and investigate
print(f'Unexpected error: {error}')
await log_outreach_error(lead.id, error)
return {'success': False, 'error_label': error_label}
def tomorrow():
date = datetime.now() + timedelta(days=1)
return date.replace(hour=9, minute=0, second=0, microsecond=0).isoformat()
```
**Full error reference:** [Error Reference →](/v1/error-reference)
***
## Section 8: Optimized Sync Flow (last\_message optimization)
The `last_message` field in `extract-conversations` contains the sender's `linkedin_profile_id`. This lets you detect replies without calling `extract-messages`.
```javascript JavaScript theme={null}
// Sync conversations and detect replies efficiently
async function syncConversations(identityId) {
const userProfileId = await getUserProfileId(identityId);
const response = await fetch('https://api.edges.run/v1/actions/linkedin-extract-conversations/run/live', {
method: 'POST',
headers: {
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
body: JSON.stringify({
identity_ids: [identityId]
})
});
const data = await response.json();
for (const conv of data) {
const lastSenderId = conv.last_message?.linkedin_profile_id;
// If last message sender != user, the lead replied!
if (lastSenderId && lastSenderId !== userProfileId) {
const leadProfileId = conv.participants[0]?.linkedin_profile_id;
await markLeadAsReplied(identityId, leadProfileId);
// NO NEED to call extract-messages for reply detection!
}
// Cache conversation for de-dup
await upsertConversation({
identity_id: identityId,
linkedin_thread_id: conv.linkedin_thread_id,
participant_profile_id: conv.participants[0]?.linkedin_profile_id,
last_message_sender_id: lastSenderId,
last_message_at: conv.last_message?.delivered_at
});
}
}
```
```python Python theme={null}
async def sync_conversations(identity_id: str):
"""Sync conversations and detect replies efficiently."""
user_profile_id = await get_user_profile_id(identity_id)
response = requests.post(
'https://api.edges.run/v1/actions/linkedin-extract-conversations/run/live',
headers={
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
json={
'identity_ids': [identity_id]
}
)
data = response.json()
for conv in data:
last_sender_id = conv.get('last_message', {}).get('linkedin_profile_id')
# If last message sender != user, the lead replied!
if last_sender_id and last_sender_id != user_profile_id:
lead_profile_id = conv['participants'][0].get('linkedin_profile_id')
await mark_lead_as_replied(identity_id, lead_profile_id)
# NO NEED to call extract-messages for reply detection!
# Cache conversation for de-dup
await upsert_conversation(
identity_id=identity_id,
linkedin_thread_id=conv['linkedin_thread_id'],
participant_profile_id=conv['participants'][0].get('linkedin_profile_id'),
last_message_sender_id=last_sender_id,
last_message_at=conv.get('last_message', {}).get('delivered_at')
)
```
**When you DO need `extract-messages`:**
* **Building a Lemlist-like inbox UI** - Display full conversation threads to users in your app
* Full conversation history for CRM sync
* Message analytics/sentiment analysis
* Compliance/audit requirements
***
## Section 9: Sending Outreach Actions (Complete Examples)
### Send a Connection Request
```javascript JavaScript theme={null}
async function sendConnectionRequest(identityId, lead, message = null) {
const response = await fetch('https://api.edges.run/v1/actions/linkedin-connect-profile/run/live', {
method: 'POST',
headers: {
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
body: JSON.stringify({
identity_ids: [identityId],
parameters: {
message: message // Optional, 300 char limit. Only 5/month with note!
},
input: {
linkedin_profile_url: lead.linkedin_profile_url
}
})
});
if (!response.ok) {
const error = await response.json();
throw error;
}
const data = await response.json();
// Update lead status
await updateLead(lead.id, {
connection_status: 'PENDING',
connection_sent_at: new Date().toISOString(),
last_contacted_at: new Date().toISOString()
});
// Log the action
await logOutreach(lead.id, 'CONNECT', data.run_id);
return data;
}
```
```python Python theme={null}
async def send_connection_request(identity_id: str, lead, message: str = None):
response = requests.post(
'https://api.edges.run/v1/actions/linkedin-connect-profile/run/live',
headers={
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
json={
'identity_ids': [identity_id],
'parameters': {
'message': message # Optional, 300 char limit. Only 5/month with note!
},
'input': {
'linkedin_profile_url': lead.linkedin_profile_url
}
}
)
if not response.ok:
raise EdgesError(response.json())
data = response.json()
# Update lead status
await update_lead(lead.id,
connection_status='PENDING',
connection_sent_at=datetime.now().isoformat(),
last_contacted_at=datetime.now().isoformat()
)
# Log the action
await log_outreach(lead.id, 'CONNECT', data['run_id'])
return data
```
### Send a Message
```javascript JavaScript theme={null}
async function sendMessage(identityId, lead, messageText) {
const response = await fetch('https://api.edges.run/v1/actions/linkedin-message-profile/run/live', {
method: 'POST',
headers: {
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
body: JSON.stringify({
identity_ids: [identityId],
parameters: {
message: messageText
},
input: {
linkedin_profile_url: lead.linkedin_profile_url
}
})
});
if (!response.ok) {
const error = await response.json();
throw error;
}
const data = await response.json();
// Update lead status
await updateLead(lead.id, {
sequence_status: 'WAITING_REPLY',
last_contacted_at: new Date().toISOString()
});
// Log the action
await logOutreach(lead.id, 'MESSAGE', data.run_id);
return data;
}
```
```python Python theme={null}
async def send_message(identity_id: str, lead, message_text: str):
response = requests.post(
'https://api.edges.run/v1/actions/linkedin-message-profile/run/live',
headers={
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
json={
'identity_ids': [identity_id],
'parameters': {
'message': message_text
},
'input': {
'linkedin_profile_url': lead.linkedin_profile_url
}
}
)
if not response.ok:
raise EdgesError(response.json())
data = response.json()
# Update lead status
await update_lead(lead.id,
sequence_status='WAITING_REPLY',
last_contacted_at=datetime.now().isoformat()
)
# Log the action
await log_outreach(lead.id, 'MESSAGE', data['run_id'])
return data
```
***
## Section 10: De-duplication Logic
Before sending any outreach, check for existing conversations and pending requests.
```javascript JavaScript theme={null}
async function canSendOutreach(identityId, lead) {
// Check 1: Already replied?
if (lead.sequence_status === 'REPLIED') {
return { canSend: false, reason: 'ALREADY_REPLIED' };
}
// Check 2: Pending connection request?
if (lead.connection_status === 'PENDING') {
const daysSinceSent = daysBetween(lead.connection_sent_at, new Date());
if (daysSinceSent < 21) {
return { canSend: false, reason: 'CONNECTION_PENDING' };
}
}
// Check 3: Existing conversation? (from synced data)
const existingConv = await db.conversations.findFirst({
where: {
identity_id: identityId,
participant_profile_id: lead.linkedin_profile_id
}
});
if (existingConv) {
const userProfileId = await getUserProfileId(identityId);
// Lead replied - last message is from them
if (existingConv.last_message_sender_id !== userProfileId) {
await updateLead(lead.id, { sequence_status: 'REPLIED' });
return { canSend: false, reason: 'LEAD_REPLIED' };
}
// We already messaged, check cooldown
const daysSinceMessage = daysBetween(existingConv.last_message_at, new Date());
if (daysSinceMessage < 7) {
return { canSend: false, reason: 'COOLDOWN_ACTIVE' };
}
}
return { canSend: true };
}
function daysBetween(date1, date2) {
const diffMs = new Date(date2) - new Date(date1);
return Math.floor(diffMs / (1000 * 60 * 60 * 24));
}
```
```python Python theme={null}
from datetime import datetime
async def can_send_outreach(identity_id: str, lead):
# Check 1: Already replied?
if lead.sequence_status == 'REPLIED':
return {'can_send': False, 'reason': 'ALREADY_REPLIED'}
# Check 2: Pending connection request?
if lead.connection_status == 'PENDING':
days_since_sent = days_between(lead.connection_sent_at, datetime.now())
if days_since_sent < 21:
return {'can_send': False, 'reason': 'CONNECTION_PENDING'}
# Check 3: Existing conversation? (from synced data)
existing_conv = await db.conversations.find_first(
identity_id=identity_id,
participant_profile_id=lead.linkedin_profile_id
)
if existing_conv:
user_profile_id = await get_user_profile_id(identity_id)
# Lead replied - last message is from them
if existing_conv.last_message_sender_id != user_profile_id:
await update_lead(lead.id, sequence_status='REPLIED')
return {'can_send': False, 'reason': 'LEAD_REPLIED'}
# We already messaged, check cooldown
days_since_message = days_between(existing_conv.last_message_at, datetime.now())
if days_since_message < 7:
return {'can_send': False, 'reason': 'COOLDOWN_ACTIVE'}
return {'can_send': True}
def days_between(date1, date2):
diff = date2 - date1
return diff.days
```
***
## Section 11: Business Hours & Timezone Sending
Send messages during the lead's business hours for better response rates.
```javascript JavaScript theme={null}
function getSendTime(lead) {
// Default business hours: 9am - 6pm in lead's timezone
const targetHour = 9 + Math.floor(Math.random() * 9); // Random hour 9-17
const targetMinute = Math.floor(Math.random() * 60);
// Get lead's timezone offset (you'd lookup from location)
const leadTimezone = getTimezoneFromLocation(lead.location) || 'America/New_York';
const now = new Date();
const sendTime = new Date(now);
// Set to target time in lead's timezone
sendTime.setHours(targetHour, targetMinute, 0, 0);
// If it's past business hours today, schedule for tomorrow
const nowInLeadTz = new Date(now.toLocaleString('en-US', { timeZone: leadTimezone }));
if (nowInLeadTz.getHours() >= 18) {
sendTime.setDate(sendTime.getDate() + 1);
}
// Skip weekends
while (sendTime.getDay() === 0 || sendTime.getDay() === 6) {
sendTime.setDate(sendTime.getDate() + 1);
}
return sendTime;
}
// Helper: Map location to timezone (implement based on your data)
function getTimezoneFromLocation(location) {
const timezoneMap = {
'San Francisco': 'America/Los_Angeles',
'New York': 'America/New_York',
'London': 'Europe/London',
'Paris': 'Europe/Paris',
// Add more mappings
};
for (const [city, tz] of Object.entries(timezoneMap)) {
if (location?.includes(city)) return tz;
}
return null;
}
```
```python Python theme={null}
from datetime import datetime, timedelta
import random
def get_send_time(lead):
"""Calculate optimal send time in lead's business hours."""
# Default business hours: 9am - 6pm in lead's timezone
target_hour = 9 + random.randint(0, 8) # Random hour 9-17
target_minute = random.randint(0, 59)
# Get lead's timezone (you'd lookup from location)
lead_timezone = get_timezone_from_location(lead.location) or 'America/New_York'
now = datetime.now()
send_time = now.replace(hour=target_hour, minute=target_minute, second=0, microsecond=0)
# If it's past business hours today, schedule for tomorrow
if now.hour >= 18:
send_time += timedelta(days=1)
# Skip weekends (0=Monday, 6=Sunday in Python)
while send_time.weekday() >= 5: # Saturday=5, Sunday=6
send_time += timedelta(days=1)
return send_time
def get_timezone_from_location(location: str) -> str:
"""Map location to timezone. Implement based on your data."""
timezone_map = {
'San Francisco': 'America/Los_Angeles',
'New York': 'America/New_York',
'London': 'Europe/London',
'Paris': 'Europe/Paris',
# Add more mappings
}
if not location:
return None
for city, tz in timezone_map.items():
if city in location:
return tz
return None
```
***
## Section 12: Callback Correlation with custom\_data
When using async execution, pass `custom_data` to correlate callbacks with your leads.
```javascript JavaScript theme={null}
// Send async action with custom_data
async function sendAsyncMessage(identityId, lead) {
const response = await fetch('https://api.edges.run/v1/actions/linkedin-message-profile/run/async', {
method: 'POST',
headers: {
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
body: JSON.stringify({
identity_ids: [identityId],
parameters: {
message: 'Hi! I wanted to connect...'
},
inputs: [{
linkedin_profile_url: lead.linkedin_profile_url,
custom_data: {
lead_id: lead.id,
step: 'initial_message',
identity_id: identityId
}
}],
callback: {
url: 'https://your-app.com/webhooks/edges'
}
})
});
return response.json();
}
// Handle callback in your webhook endpoint
app.post('/webhooks/edges', async (req, res) => {
const { run_id, status, output, custom_data } = req.body;
// custom_data contains exactly what you sent
const { lead_id, step, identity_id } = custom_data;
if (status === 'SUCCESS') {
await updateLead(lead_id, {
sequence_status: 'WAITING_REPLY',
last_contacted_at: new Date().toISOString()
});
} else {
await logOutreachError(lead_id, output.error_label);
}
res.status(200).send('OK');
});
```
```python Python theme={null}
import requests
from flask import Flask, request
# Send async action with custom_data
async def send_async_message(identity_id: str, lead):
response = requests.post(
'https://api.edges.run/v1/actions/linkedin-message-profile/run/async',
headers={
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
json={
'identity_ids': [identity_id],
'parameters': {
'message': 'Hi! I wanted to connect...'
},
'inputs': [{
'linkedin_profile_url': lead.linkedin_profile_url,
'custom_data': {
'lead_id': str(lead.id),
'step': 'initial_message',
'identity_id': identity_id
}
}],
'callback': {
'url': 'https://your-app.com/webhooks/edges'
}
}
)
return response.json()
# Handle callback in your webhook endpoint
app = Flask(__name__)
@app.route('/webhooks/edges', methods=['POST'])
async def handle_edges_callback():
data = request.json
run_id = data['run_id']
status = data['status']
output = data.get('output', {})
custom_data = data.get('custom_data', {})
# custom_data contains exactly what you sent
lead_id = custom_data.get('lead_id')
step = custom_data.get('step')
identity_id = custom_data.get('identity_id')
if status == 'SUCCESS':
await update_lead(lead_id,
sequence_status='WAITING_REPLY',
last_contacted_at=datetime.now().isoformat()
)
else:
await log_outreach_error(lead_id, output.get('error_label'))
return 'OK', 200
```
See [Callbacks Documentation →](/v1/runs/callbacks) for full callback payload structure.
***
## Section 13: Rate Limits & Scaling
Understand both types of limits:
### 1. LinkedIn Smart Limits (per identity, per action)
These protect individual LinkedIn accounts from restrictions:
* 25-30 connections/day
* 50-250 messages/day
* See [LinkedIn Smart Limits →](/v1/linkedin/limits)
### 2. API Rate Limits (per workspace)
Based on your Edges plan tier. See [API Rate Limits →](/v1/runs/rate-limits)
### Choosing the Right Execution Mode
Choose based on **when and how** you need the action executed:
| Mode | Use Case | Example |
| ---------- | -------------------------------------------------- | ------------------------------------- |
| `live` | Real-time user action, need immediate result | User clicks "Send Message" in your UI |
| `async` | Background bulk operations, process callback later | Import 500 leads and message them all |
| `schedule` | Recurring automation on a schedule | Daily sync of connections at 9am |
**Implementation stays the same regardless of user count**. Your architecture should support all modes from day 1 based on feature requirements, not scale.
**Best practice:** Space out requests. Instead of bursting 50 messages at once, spread them across the day using job queues or scheduled runs.
***
## Section 14: When to Sync Data
Knowing **when** to sync connections and conversations is critical for accurate outreach.
### Connections Extraction
| When | Why | Mode |
| ------------------------------------ | ------------------------------------- | ------------------------ |
| **After identity connects LinkedIn** | Initial cache of existing connections | `live` or `async` |
| **Daily (e.g., 9am)** | Catch newly accepted requests | `schedule` |
| **Before starting a new lead** | Check if already connected | Part of lead import flow |
```javascript JavaScript theme={null}
// Schedule daily connections sync (use /run/schedule)
// Or call this on a cron job using /run/async
async function syncConnections(identityId) {
const response = await fetch('https://api.edges.run/v1/actions/linkedin-extract-connections/run/live', {
method: 'POST',
headers: {
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
body: JSON.stringify({
identity_ids: [identityId]
})
});
const connections = await response.json();
// Update your connections cache
for (const conn of connections) {
await upsertConnection({
identity_id: identityId,
linkedin_profile_id: conn.linkedin_profile_id,
linkedin_profile_url: conn.linkedin_profile_url,
connected_at: conn.connected_at
});
}
return connections.length;
}
```
```python Python theme={null}
async def sync_connections(identity_id: str):
"""Sync connections - call daily or after identity setup."""
response = requests.post(
'https://api.edges.run/v1/actions/linkedin-extract-connections/run/live',
headers={
'X-API-Key': EDGES_API_KEY,
'Content-Type': 'application/json'
},
json={
'identity_ids': [identity_id]
}
)
connections = response.json()
# Update your connections cache
for conn in connections:
await upsert_connection(
identity_id=identity_id,
linkedin_profile_id=conn['linkedin_profile_id'],
linkedin_profile_url=conn['linkedin_profile_url'],
connected_at=conn.get('connected_at')
)
return len(connections)
```
### Conversations Extraction
| When | Why | Mode |
| ------------------------------ | --------------------------------------------- | ------------------ |
| **Before sending any message** | Check for replies (sync-before-send) | `live` |
| **Every 1-4 hours** | Update conversation cache, detect new replies | `schedule` or cron |
| **On demand (inbox UI)** | Show user their latest conversations | `live` |
**Schedule mode is ideal for recurring syncs.** Set up a schedule to run `extract-connections` daily and `extract-conversations` every few hours. See [Scheduled Runs →](/v1/runs/schedules)
***
## Section 15: Sync-Before-Send Pattern (Race Condition Prevention)
**Problem:** If you sync at 8:00am but send at 8:05am, lead could have replied at 8:03am.
**Solution:** Always sync immediately before sending:
```javascript JavaScript theme={null}
async function executeOutreachWithSync(identityId, lead) {
// Step 1: Fresh sync for this specific lead
// Note: extractConversations() wraps the API call from Section 8
const conversations = await extractConversations(identityId, { max_results: 50 });
// Step 2: Check if lead replied since last sync
const userProfileId = await getUserProfileId(identityId);
for (const conv of conversations) {
const participantId = conv.participants[0]?.linkedin_profile_id;
if (participantId === lead.linkedin_profile_id) {
if (conv.last_message?.linkedin_profile_id !== userProfileId) {
// Lead replied! Abort outreach
await updateLead(lead.id, { sequence_status: 'REPLIED' });
return { status: 'skipped', reason: 'LEAD_REPLIED_SINCE_SYNC' };
}
}
}
// Step 3: Safe to send
return await sendMessage(identityId, lead);
}
```
```python Python theme={null}
async def execute_outreach_with_sync(identity_id: str, lead):
"""Sync conversations immediately before sending to prevent race conditions."""
# Step 1: Fresh sync for this specific lead
# Note: extract_conversations() wraps the API call from Section 8
conversations = await extract_conversations(identity_id, max_results=50)
# Step 2: Check if lead replied since last sync
user_profile_id = await get_user_profile_id(identity_id)
for conv in conversations:
participant_id = conv['participants'][0].get('linkedin_profile_id')
if participant_id == lead.linkedin_profile_id:
last_sender = conv.get('last_message', {}).get('linkedin_profile_id')
if last_sender != user_profile_id:
# Lead replied! Abort outreach
await update_lead(lead.id, sequence_status='REPLIED')
return {'status': 'skipped', 'reason': 'LEAD_REPLIED_SINCE_SYNC'}
# Step 3: Safe to send
return await send_message(identity_id, lead)
```
**Acceptable staleness:** 5-10 minutes for most use cases. For high-value leads, sync immediately before.
***
## Section 16: Identity Failure Recovery
**Prerequisite:** Set up integration webhooks. See [Monitor LinkedIn Integration Status →](/v1/identities/linkedin#monitor-linkedin-integration-status-with-webhooks)
**When identity auth expires (webhook event: `AUTH_EXPIRED`):**
```javascript JavaScript theme={null}
// Webhook handler for identity status changes
app.post('/webhooks/edges/integration', async (req, res) => {
const { identity_uid, event_type, integration_type } = req.body;
if (integration_type !== 'linkedin') {
return res.status(200).send('OK');
}
switch (event_type) {
case 'AUTH_EXPIRED':
await handleIdentityAuthExpired(identity_uid);
break;
case 'AUTH_SUCCESS':
await handleIdentityAuthRestored(identity_uid);
break;
}
res.status(200).send('OK');
});
async function handleIdentityAuthExpired(identityUid) {
// 1. Pause all leads in active sequences for this identity
await db.leads.updateMany({
where: {
identity_id: identityUid,
sequence_status: { in: ['IN_SEQUENCE', 'WAITING_REPLY'] }
},
data: {
sequence_status: 'PAUSED',
paused_reason: 'IDENTITY_AUTH_EXPIRED',
paused_at: new Date()
}
});
// 2. Notify user to re-authenticate
const user = await getUserFromIdentity(identityUid);
await sendNotification(user.id, {
type: 'LINKEDIN_AUTH_EXPIRED',
message: 'Your LinkedIn connection expired. Please reconnect to resume sequences.',
action_url: '/settings/integrations'
});
}
async function handleIdentityAuthRestored(identityUid) {
// Resume paused leads
await db.leads.updateMany({
where: {
identity_id: identityUid,
sequence_status: 'PAUSED',
paused_reason: 'IDENTITY_AUTH_EXPIRED'
},
data: {
sequence_status: 'IN_SEQUENCE',
paused_reason: null,
next_action_at: new Date() // Reschedule immediately
}
});
}
```
```python Python theme={null}
from flask import Flask, request
app = Flask(__name__)
@app.route('/webhooks/edges/integration', methods=['POST'])
async def handle_integration_webhook():
data = request.json
identity_uid = data['identity_uid']
event_type = data['event_type']
integration_type = data['integration_type']
if integration_type != 'linkedin':
return 'OK', 200
if event_type == 'AUTH_EXPIRED':
await handle_identity_auth_expired(identity_uid)
elif event_type == 'AUTH_SUCCESS':
await handle_identity_auth_restored(identity_uid)
return 'OK', 200
async def handle_identity_auth_expired(identity_uid: str):
"""Pause all sequences when LinkedIn auth expires."""
# 1. Pause all leads in active sequences for this identity
await db.execute("""
UPDATE leads
SET sequence_status = 'PAUSED',
paused_reason = 'IDENTITY_AUTH_EXPIRED',
paused_at = NOW()
WHERE identity_id = %s
AND sequence_status IN ('IN_SEQUENCE', 'WAITING_REPLY')
""", [identity_uid])
# 2. Notify user to re-authenticate
user = await get_user_from_identity(identity_uid)
await send_notification(
user_id=user.id,
notification_type='LINKEDIN_AUTH_EXPIRED',
message='Your LinkedIn connection expired. Please reconnect to resume sequences.',
action_url='/settings/integrations'
)
async def handle_identity_auth_restored(identity_uid: str):
"""Resume paused leads when LinkedIn auth is restored."""
await db.execute("""
UPDATE leads
SET sequence_status = 'IN_SEQUENCE',
paused_reason = NULL,
next_action_at = NOW()
WHERE identity_id = %s
AND sequence_status = 'PAUSED'
AND paused_reason = 'IDENTITY_AUTH_EXPIRED'
""", [identity_uid])
```
***
## Section 17: Handling Edge Cases (Already Connected, Lead Messaged First)
When adding a lead to a sequence, check for existing relationships:
```javascript JavaScript theme={null}
async function addLeadToSequence(identityId, lead) {
// Step 1: Check if already connected
// Note: Helper functions wrap the API calls shown in previous sections
const connections = await extractConnections(identityId, { max_results: 1000 });
const isConnected = connections.some(
conn => conn.linkedin_profile_id === lead.linkedin_profile_id
);
if (isConnected) {
lead.connection_status = 'CONNECTED';
lead.current_step = 3; // Skip to message step
await saveLead(lead);
return;
}
// Step 2: Check if conversation exists (lead may have messaged first)
const conversations = await extractConversations(identityId, { max_results: 100 });
for (const conv of conversations) {
if (conv.participants[0]?.linkedin_profile_id === lead.linkedin_profile_id) {
// Existing conversation! Check who initiated
const userProfileId = await getUserProfileId(identityId);
if (conv.last_message?.linkedin_profile_id === lead.linkedin_profile_id) {
lead.sequence_status = 'REPLIED';
lead.replied_at = conv.last_message.delivered_at;
await saveLead(lead);
return; // Don't start sequence, human should handle
}
}
}
// Step 3: Normal start
lead.sequence_status = 'IN_SEQUENCE';
lead.current_step = 0;
lead.next_action_at = new Date();
await saveLead(lead);
}
```
```python Python theme={null}
async def add_lead_to_sequence(identity_id: str, lead):
"""Add a lead to sequence with edge case handling."""
# Step 1: Check if already connected
# Note: Helper functions wrap the API calls shown in previous sections
connections = await extract_connections(identity_id, max_results=1000)
is_connected = any(
conn['linkedin_profile_id'] == lead.linkedin_profile_id
for conn in connections
)
if is_connected:
lead.connection_status = 'CONNECTED'
lead.current_step = 3 # Skip to message step
await save_lead(lead)
return
# Step 2: Check if conversation exists (lead may have messaged first)
conversations = await extract_conversations(identity_id, max_results=100)
for conv in conversations:
participant_id = conv['participants'][0].get('linkedin_profile_id')
if participant_id == lead.linkedin_profile_id:
# Existing conversation! Check who initiated
user_profile_id = await get_user_profile_id(identity_id)
last_sender = conv.get('last_message', {}).get('linkedin_profile_id')
if last_sender == lead.linkedin_profile_id:
lead.sequence_status = 'REPLIED'
lead.replied_at = conv['last_message']['delivered_at']
await save_lead(lead)
return # Don't start sequence, human should handle
# Step 3: Normal start
lead.sequence_status = 'IN_SEQUENCE'
lead.current_step = 0
lead.next_action_at = datetime.now()
await save_lead(lead)
```
***
## Section 18: Complete Orchestrator Example
This ties everything together. A daily cron job that processes all leads for all identities.
```javascript JavaScript theme={null}
// Main orchestrator - runs daily via cron
async function runDailyOutreachForAllIdentities() {
// Get all active identities
const identities = await db.identities.findMany({
where: { status: 'ACTIVE', linkedin_connected: true }
});
for (const identity of identities) {
try {
await runOutreachForIdentity(identity.id);
} catch (error) {
console.error(`Failed for identity ${identity.id}:`, error);
// Continue with other identities
}
}
}
async function runOutreachForIdentity(identityId) {
// Step 1: Sync conversations to detect replies (Section 8)
await syncConversations(identityId);
// Step 2: Get leads due for action today
const leads = await db.leads.findMany({
where: {
identity_id: identityId,
sequence_status: 'IN_SEQUENCE',
next_action_at: { lte: new Date() }
}
});
for (const lead of leads) {
// Step 3: De-dup check (Section 10)
const { canSend, reason } = await canSendOutreach(identityId, lead);
if (!canSend) {
console.log(`Skipping lead ${lead.id}: ${reason}`);
continue;
}
// Step 4: Sync-before-send for race condition prevention (Section 14)
const replyCheck = await checkForRecentReply(identityId, lead);
if (replyCheck.hasReplied) {
await updateLead(lead.id, { sequence_status: 'REPLIED' });
continue;
}
// Step 5: Calculate send time for business hours (Section 11)
const sendTime = getSendTime(lead);
if (sendTime > new Date()) {
await updateLead(lead.id, { next_action_at: sendTime });
continue;
}
// Step 6: Execute the action (Section 9) with error handling (Section 7)
await executeWithErrorHandling(identityId, lead, async () => {
return await executeSequenceStep(identityId, lead);
});
}
}
async function executeSequenceStep(identityId, lead) {
const SEQUENCE_STEPS = [
{ step: 0, action: 'visit', delayDays: 1 },
{ step: 1, action: 'connect', delayDays: 3 },
{ step: 2, action: 'follow_up_connect', delayDays: 4 }, // If not connected after 3 days
{ step: 3, action: 'message', delayDays: 7 }, // After connection accepted
{ step: 4, action: 'follow_up_1', delayDays: 7 },
{ step: 5, action: 'follow_up_2', delayDays: 7 },
{ step: 6, action: 'archive', delayDays: 0 }
];
const currentStep = SEQUENCE_STEPS[lead.current_step];
// Check connection status for message steps
if (['message', 'follow_up_1', 'follow_up_2'].includes(currentStep.action)) {
if (lead.connection_status !== 'CONNECTED') {
// Not connected yet - check if connection was accepted
// Note: Helper functions wrap API calls (see Section 9)
const connections = await extractConnections(identityId, { max_results: 100 });
const isNowConnected = connections.some(
c => c.linkedin_profile_id === lead.linkedin_profile_id
);
if (isNowConnected) {
await updateLead(lead.id, { connection_status: 'CONNECTED' });
} else {
// Still not connected - wait or move to follow-up connect
return;
}
}
}
switch (currentStep.action) {
case 'visit':
await visitProfile(identityId, lead);
break;
case 'connect':
await sendConnectionRequest(identityId, lead);
break;
case 'message':
case 'follow_up_1':
case 'follow_up_2':
const template = MESSAGE_TEMPLATES[currentStep.action];
const message = personalizeMessage(template, lead);
await sendMessage(identityId, lead, message);
break;
case 'archive':
await updateLead(lead.id, { sequence_status: 'ARCHIVED' });
return;
}
// Advance to next step
await updateLead(lead.id, {
current_step: lead.current_step + 1,
next_action_at: addDays(new Date(), currentStep.delayDays),
last_contacted_at: new Date()
});
}
// Message templates
const MESSAGE_TEMPLATES = {
message: "Hi {{first_name}}, I noticed you're working at {{company_name}}. I'd love to connect and share some ideas about...",
follow_up_1: "Hi {{first_name}}, just following up on my previous message. Would love to hear your thoughts on...",
follow_up_2: "{{first_name}}, last follow-up from me! If now isn't a good time, no worries. Feel free to reach out whenever..."
};
function personalizeMessage(template, lead) {
return template
.replace('{{first_name}}', lead.full_name?.split(' ')[0] || 'there')
.replace('{{company_name}}', lead.company_name || 'your company');
}
function addDays(date, days) {
const result = new Date(date);
result.setDate(result.getDate() + days);
return result;
}
```
```python Python theme={null}
from datetime import datetime, timedelta
# Main orchestrator - runs daily via cron
async def run_daily_outreach_for_all_identities():
"""Process outreach for all active identities."""
identities = await db.identities.find_many(
status='ACTIVE', linkedin_connected=True
)
for identity in identities:
try:
await run_outreach_for_identity(identity.id)
except Exception as e:
print(f"Failed for identity {identity.id}: {e}")
async def run_outreach_for_identity(identity_id: str):
"""Process all due leads for a single identity."""
# Step 1: Sync conversations to detect replies (Section 8)
await sync_conversations(identity_id)
# Step 2: Get leads due for action today
leads = await db.leads.find_many(
identity_id=identity_id,
sequence_status='IN_SEQUENCE',
next_action_at__lte=datetime.now()
)
for lead in leads:
# Step 3: De-dup check (Section 10)
result = await can_send_outreach(identity_id, lead)
if not result['can_send']:
print(f"Skipping lead {lead.id}: {result['reason']}")
continue
# Step 4: Sync-before-send for race condition prevention (Section 14)
if await check_for_recent_reply(identity_id, lead):
await update_lead(lead.id, sequence_status='REPLIED')
continue
# Step 5: Calculate send time for business hours (Section 11)
send_time = get_send_time(lead)
if send_time > datetime.now():
await update_lead(lead.id, next_action_at=send_time)
continue
# Step 6: Execute with error handling (Section 7)
await execute_with_error_handling(
identity_id, lead,
lambda: execute_sequence_step(identity_id, lead)
)
SEQUENCE_STEPS = [
{'step': 0, 'action': 'visit', 'delay_days': 1},
{'step': 1, 'action': 'connect', 'delay_days': 3},
{'step': 2, 'action': 'follow_up_connect', 'delay_days': 4},
{'step': 3, 'action': 'message', 'delay_days': 7},
{'step': 4, 'action': 'follow_up_1', 'delay_days': 7},
{'step': 5, 'action': 'follow_up_2', 'delay_days': 7},
{'step': 6, 'action': 'archive', 'delay_days': 0}
]
MESSAGE_TEMPLATES = {
'message': "Hi {{first_name}}, I noticed you're working at {{company_name}}. I'd love to connect and share some ideas about...",
'follow_up_1': "Hi {{first_name}}, just following up on my previous message. Would love to hear your thoughts on...",
'follow_up_2': "{{first_name}}, last follow-up from me! If now isn't a good time, no worries. Feel free to reach out whenever..."
}
async def execute_sequence_step(identity_id: str, lead):
"""Execute the current step in the lead's sequence."""
current_step = SEQUENCE_STEPS[lead.current_step]
action = current_step['action']
# Check connection status for message steps
if action in ['message', 'follow_up_1', 'follow_up_2']:
if lead.connection_status != 'CONNECTED':
# Note: Helper functions wrap API calls (see Section 9)
connections = await extract_connections(identity_id, max_results=100)
is_now_connected = any(
c['linkedin_profile_id'] == lead.linkedin_profile_id
for c in connections
)
if is_now_connected:
await update_lead(lead.id, connection_status='CONNECTED')
else:
return # Still not connected - wait
if action == 'visit':
await visit_profile(identity_id, lead)
elif action == 'connect':
await send_connection_request(identity_id, lead)
elif action in ['message', 'follow_up_1', 'follow_up_2']:
template = MESSAGE_TEMPLATES[action]
message = personalize_message(template, lead)
await send_message(identity_id, lead, message)
elif action == 'archive':
await update_lead(lead.id, sequence_status='ARCHIVED')
return
# Advance to next step
await update_lead(lead.id,
current_step=lead.current_step + 1,
next_action_at=datetime.now() + timedelta(days=current_step['delay_days']),
last_contacted_at=datetime.now()
)
def personalize_message(template: str, lead) -> str:
"""Replace placeholders with lead data."""
first_name = lead.full_name.split(' ')[0] if lead.full_name else 'there'
company = lead.company_name or 'your company'
return template \
.replace('{{first_name}}', first_name) \
.replace('{{company_name}}', company)
```
**How to run:**
* Set up a cron job: `0 8 * * * python run_daily_outreach.py`
* Or use a job queue (Bull, Celery, etc.) for better control
***
## Section 19: Testing Strategy
**Challenge:** Can't spam real LinkedIn users during development.
### Approach 1: Test Accounts
* Create 2-3 LinkedIn test accounts (personal accounts you control)
* Use these as "leads" for end-to-end testing
* Verify messages arrive, connections work
### Approach 2: Dry Run Mode
```javascript JavaScript theme={null}
async function executeAction(identityId, lead, dryRun = false) {
if (dryRun) {
// Log what WOULD happen without calling API
console.log(`DRY RUN: Would send ${lead.current_step} to ${lead.full_name}`);
return { status: 'dry_run', action: lead.current_step };
}
// Real execution
return await executeSequenceStep(identityId, lead);
}
```
```python Python theme={null}
async def execute_action(identity_id: str, lead, dry_run: bool = False):
if dry_run:
# Log what WOULD happen without calling API
print(f"DRY RUN: Would send step {lead.current_step} to {lead.full_name}")
return {'status': 'dry_run', 'action': lead.current_step}
# Real execution
return await execute_sequence_step(identity_id, lead)
```
### Approach 3: Staging Environment
* Use a separate Edges workspace for testing
* Connect test identities only
* Isolates production data
### Approach 4: Unit Test Mocks
```javascript JavaScript theme={null}
// Jest example - mock Edges responses
describe('Outreach Sequence', () => {
beforeEach(() => {
jest.spyOn(global, 'fetch').mockImplementation((url) => {
if (url.includes('extract-conversations')) {
return Promise.resolve({
ok: true,
json: () => Promise.resolve({
output: {
results: [{
linkedin_thread_id: '2-test-thread',
last_message: {
linkedin_profile_id: 123456789, // Simulated lead reply
delivered_at: '2024-01-20T10:00:00Z'
},
participants: [{ linkedin_profile_id: 123456789 }]
}]
}
})
});
}
// Add more mock responses...
});
});
test('detects lead reply correctly', async () => {
const result = await syncConversations('identity_123');
// Assert lead was marked as replied
});
});
```
```python Python theme={null}
# pytest example - mock Edges responses
import pytest
from unittest.mock import patch, MagicMock
@pytest.fixture
def mock_edges_client():
with patch('requests.post') as mock_post:
mock_response = MagicMock()
mock_response.ok = True
mock_response.json.return_value = {
'output': {
'results': [{
'linkedin_thread_id': '2-test-thread',
'last_message': {
'linkedin_profile_id': 123456789, # Simulated lead reply
'delivered_at': '2024-01-20T10:00:00Z'
},
'participants': [{'linkedin_profile_id': 123456789}]
}]
}
}
mock_post.return_value = mock_response
yield mock_post
def test_detects_lead_reply(mock_edges_client):
# Your test here
result = sync_conversations('identity_123')
# Assert lead was marked as replied
```
***
## Section 20: API Reference & SDK
### TypeScript SDK
For a cleaner developer experience, use the official TypeScript SDK:
```bash theme={null}
npm install @edgesrun/sdk
```
See [SDK Documentation →](/v1/sdk)
### Key Actions Reference
Don't duplicate schemas - refer to live action docs for full request/response examples:
| Action | Key Fields You Need | Live Docs |
| -------------------------------- | -------------------------------------------------------- | -------------------------------------------------------- |
| `linkedin-me` | `linkedin_profile_id` (user's own ID) | [View →](/v1/api/actions/linkedin-me) |
| `linkedin-extract-conversations` | `last_message.linkedin_profile_id`, `linkedin_thread_id` | [View →](/v1/api/actions/linkedin-extract-conversations) |
| `linkedin-extract-connections` | `linkedin_profile_id`, `connected_at` | [View →](/v1/api/actions/linkedin-extract-connections) |
| `linkedin-message-profile` | `linkedin_thread_id` (returned on success) | [View →](/v1/api/actions/linkedin-message-profile) |
| `linkedin-connect-profile` | Success/failure status | [View →](/v1/api/actions/linkedin-connect-profile) |
| `linkedin-visit-profile` | Success/failure status | [View →](/v1/api/actions/linkedin-visit-profile) |
| `linkedin-search-people` | `linkedin_profile_url`, `full_name`, `headline` | [View →](/v1/api/actions/linkedin-search-people) |
***
## Summary
You now have everything needed to build a production-ready LinkedIn outreach sequence:
| Feature | Section |
| ----------------------------------- | ------- |
| Identity setup & concepts | 1 |
| Lead sourcing | 2 |
| User profile ID for reply detection | 3 |
| Database schema | 4 |
| State machine for lead lifecycle | 5 |
| Action limits | 6 |
| Error handling per action | 7 |
| Optimized sync with `last_message` | 8 |
| Sending messages & connections | 9 |
| De-duplication logic | 10 |
| Business hours sending | 11 |
| Callback correlation | 12 |
| Rate limits & scaling | 13 |
| Sync-before-send pattern | 14 |
| Identity failure recovery | 15 |
| Edge case handling | 16 |
| Complete orchestrator | 17 |
| Testing strategies | 18 |
| API reference & SDK | 19 |
**Questions?** Check the [FAQ](/v1/faq) or reach out to [support](https://support.edges.run).
# Edges on n8n
Source: https://docs.edges.run/v1/guides/n8n
Integrate the Edges API with n8n.
This guide targets **[n8n](https://n8n.io/cloud)** users. It uses **`linkedin-search-people`** but you can apply the same patterns to other actions by changing the path and JSON body.
**Goals:**
* **How To** — Tips and good practice to implement Edges.
* **Manage Cursor** — paginate with **`X-Pagination-Next`** until done;
* **Fewer webhooks** — use Edges `callback.on: "final"` for async so you get one callback per run, then pull data with [`GET /v1/runs/{run_uid}/outputs`](/v1/api/runs/outputs) ([Callbacks](/v1/runs/callbacks)).
***
## 1. Set the request body to JSON
Use an **HTTP Request** node:
1. **Method** `POST`.
2. Enable **Send Body**.
3. Body Content Type → **JSON**.
4. Paste or build your JSON.
![n8n Cloud HTTP Request node showing JSON body configuration for Edges API]()
You can also set the `Accept: application/json` header to ensure the response is in JSON format.
***
## 2. Send the `X-API-Key` header
For each request to the Edges API you need to authenticate thanks to your API key.
Edges authenticates with **`X-API-Key`** (not Bearer).
Add a header field
![n8n Cloud HTTP Request headers with X-API-Key for Edges API]()
Consider creating a **Custom Authentication** using n8n's Generic Credential Type. This allows you to securely **store and reuse your credentials** across all HTTP Request nodes in your workflows, improving both security and convenience.
![n8n Cloud HTTP Request with Custom Auth for Edges API]()
***
## 3. Show headers and body
Enable **Include Response Headers and Status** / **Full response** (wording depends on n8n version).
The item shape is typically like `{ body, headers, statusCode }` so the next step can read `headers['x-pagination-next']`.
![n8n Cloud HTTP Request showing headers, JSON body, and full response option for Edges]()
***
## Live mode: native loop on `X-Pagination-Next`
In **live** mode, Edges returns the next page as a **full URL** in the **`X-Pagination-Next`** header.
Call it **exactly** as returned. stop when the header is missing or empty.
### Simple implementation
1. Edit Field `cursor` to empty string or with the returned cursor header ← `{{ $runIndex === 0 ? '' : $('Extract Pagination Cursor').first().json.pagination_cursor }}`
2. Check if `cursor` is set. If empty then launch the first request. If cursor exist then go to the cursor request.
3. HTTP Request — `POST` to `https://api.edges.run/v1/actions/linkedin-search-people/run/live` and **full response** enabled. Or use the `cursor` as URL.
4. Edit Field — extract `cursor`
5. Check if `cursor` is returned. If cursor exist then go back to the first step of the loop !
6. If no cursor is returned then continue. **You have to process or store the results during the loop**.
Add a **max iteration** safeguard (n8n workflow settings timeout, or a small counter — see [optional Code](#optional-merge-many-pages-code-only-if-needed)) so a bug cannot run forever.
![n8n Cloud workflow: Set, IF, and HTTP Request loop for Edges live pagination]()
### Importable workflow (live loop)
Replace the placeholder key in both HTTP nodes after import. Complete the canvas so **HTTP Next page** connects back to **Extract pagination**.
Copy Paste this json directly into your n8n workflow editor
Then edit the API keys and input request URL
```json theme={null}
{
"nodes": [
{
"parameters": {},
"type": "n8n-nodes-base.manualTrigger",
"typeVersion": 1,
"position": [-256, -272],
"id": "ebf5bc97-b994-4c4f-9784-f04bca7f0bec",
"name": "When clicking ‘Execute workflow’"
},
{
"parameters": {
"conditions": {
"options": {
"caseSensitive": true,
"leftValue": "",
"typeValidation": "strict",
"version": 3
},
"conditions": [
{
"id": "1b593099-50d6-4fa7-85b3-bd41ccb0e989",
"leftValue": "={{ $json.cursor }}",
"rightValue": "''",
"operator": {
"type": "string",
"operation": "empty",
"singleValue": true
}
}
],
"combinator": "and"
},
"options": {}
},
"type": "n8n-nodes-base.if",
"typeVersion": 2.3,
"position": [224, -272],
"id": "2dd0338d-de01-4847-9f31-6546b5899597",
"name": "If"
},
{
"parameters": {
"method": "POST",
"url": "https://api.edges.run/v1/actions/salesnavigator-search-people/run/live",
"sendQuery": true,
"queryParameters": {
"parameters": [
{
"name": "page_size",
"value": "25"
}
]
},
"sendHeaders": true,
"headerParameters": {
"parameters": [
{
"name": "X-API-Key",
"value": "xxxx-MY-EDGES-API-KEY-xxxx"
}
]
},
"sendBody": true,
"specifyBody": "json",
"jsonBody": "={\n \"input\": {\n \"sales_navigator_profile_search_url\": \"https://www.linkedin.com/sales/search/people?[REDACTED_SAVED_SEARCH_OR_QUERY]\",\n \"custom_data\": {}\n },\n \"parameters\": {\n \"exclude_crm_contacts\": false,\n \"exclude_viewed_leads\": false\n },\n \"identity_mode\": \"managed\"\n}",
"options": {
"response": {
"response": {
"fullResponse": true
}
}
}
},
"type": "n8n-nodes-base.httpRequest",
"typeVersion": 4.3,
"position": [512, -384],
"id": "980d947a-c966-47ab-b4f6-fd9b0c5cfc3f",
"name": "First Request"
},
{
"parameters": {
"method": "POST",
"url": "={{ $('Extract Pagination Cursor').first().json.pagination_cursor }}",
"sendQuery": true,
"queryParameters": {
"parameters": [
{
"name": "page_size",
"value": "25"
}
]
},
"sendHeaders": true,
"headerParameters": {
"parameters": [
{
"name": "X-API-Key",
"value": "xxxx-MY-EDGES-API-KEY-xxxx"
}
]
},
"sendBody": true,
"specifyBody": "json",
"jsonBody": "={\n \"input\": {\n \"sales_navigator_profile_search_url\": \"https://www.linkedin.com/sales/search/people?[REDACTED_SAVED_SEARCH_OR_QUERY]\",\n \"custom_data\": {}\n },\n \"parameters\": {\n \"exclude_crm_contacts\": false,\n \"exclude_viewed_leads\": false\n },\n \"identity_mode\": \"managed\"\n}",
"options": {
"response": {
"response": {
"fullResponse": true
}
}
}
},
"type": "n8n-nodes-base.httpRequest",
"typeVersion": 4.3,
"position": [512, -208],
"id": "d2afc651-7e49-4d1d-8e92-50c8ff498e93",
"name": "Cursor Request"
},
{
"parameters": {
"assignments": {
"assignments": [
{
"id": "id-1",
"name": "cursor",
"value": "={{ $runIndex === 0 ? '' : $('Extract Pagination Cursor').first().json.pagination_cursor }}",
"type": "string"
}
]
},
"includeOtherFields": true,
"options": {}
},
"id": "3c05caa0-ea80-4a3b-b476-db7f29f2be90",
"name": "Loop Start",
"type": "n8n-nodes-base.set",
"typeVersion": 3.4,
"position": [16, -272]
},
{
"parameters": {
"assignments": {
"assignments": [
{
"id": "id-1",
"name": "pagination_cursor",
"value": "={{ $json.headers['x-pagination-next'] }}",
"type": "string"
},
{
"id": "id-2",
"name": "results",
"value": "={{ $json.body }}",
"type": "array"
}
]
},
"includeOtherFields": true,
"options": {}
},
"id": "f4528818-b1d3-46a9-a657-f5891e5b90ca",
"name": "Extract Pagination Cursor",
"type": "n8n-nodes-base.set",
"typeVersion": 3.4,
"position": [848, -272]
},
{
"parameters": {
"conditions": {
"options": {
"caseSensitive": true,
"leftValue": "",
"typeValidation": "strict",
"version": 3
},
"conditions": [
{
"id": "id-1",
"leftValue": "={{ $('Extract Pagination Cursor').first().json.pagination_cursor }}",
"operator": {
"type": "string",
"operation": "notEmpty"
}
}
],
"combinator": "and"
},
"options": {}
},
"id": "2f279d41-385d-4f9b-a8e7-28f26b3d4e9f",
"name": "More Pages?",
"type": "n8n-nodes-base.if",
"typeVersion": 2.3,
"position": [1072, -224]
}
],
"connections": {
"When clicking ‘Execute workflow’": {
"main": [[{ "node": "Loop Start", "type": "main", "index": 0 }]]
},
"If": {
"main": [
[{ "node": "First Request", "type": "main", "index": 0 }],
[{ "node": "Cursor Request", "type": "main", "index": 0 }]
]
},
"First Request": {
"main": [[{ "node": "Extract Pagination Cursor", "type": "main", "index": 0 }]]
},
"Cursor Request": {
"main": [[{ "node": "Extract Pagination Cursor", "type": "main", "index": 0 }]]
},
"Loop Start": {
"main": [[{ "node": "If", "type": "main", "index": 0 }]]
},
"Extract Pagination Cursor": {
"main": [[{ "node": "More Pages?", "type": "main", "index": 0 }]]
},
"More Pages?": {
"main": [
[{ "node": "Loop Start", "type": "main", "index": 0 }],
[]
]
}
},
"pinData": {},
"meta": {
"templateCredsSetupCompleted": false
}
}
```
***
## Async mode: `final` webhook + outputs pagination
### Why `callback.on: "final"`
With `"final"`, Edges sends **one** callback when the run finishes instead of streaming many callbacks. That fits n8n Cloud well: one **Webhook** execution per run, then you pull the full result set with the outputs API ([Streaming vs final callbacks](/v1/runs/callbacks#streaming-vs-final-callbacks)).
### Start the async run
HTTP Request POST on `https://api.edges.run/v1/actions/linkedin-search-people/run/async`
Body example (replace the webhook URL with yours):
```json theme={null}
{
"parameters": {},
"identity_mode": "managed",
"callback": {
"url": "https://YOUR-SUBDOMAIN.app.n8n.cloud/webhook/edges-async-final",
"on": "final"
}
}
```
### When the Webhook fires
The payload includes **`run.run_uid`** (see [Callbacks](/v1/runs/callbacks#final-mode-%22final%22)). Use **Edit Fields (Set)**:
1. **HTTP Request** — method **GET**. In the URL field, use the `runUid` returned to the callback.
` https://api.edges.run/v1/runs/{{ $json.runUid }}/outputs` and enable **full response**.
2. Same **Set / IF / HTTP** pattern as live mode:
* `nextUrl` from `x-pagination-next`
3. Loop until no cursor are returned.
***
## Related Edges documentation
* [Pagination](/v1/runs/pagination)
* [Callbacks](/v1/runs/callbacks) — **`on: "final"`**
* [Get run outputs](/v1/api/runs/outputs)
* [Runs overview](/v1/runs/overview)
* [API introduction](/v1/api/introduction)
# Adding & Managing Identities
Source: https://docs.edges.run/v1/identities/add-manage-identities
Comprehensive guide to syncing Identities and Integrations with the Edges API v1.
The first step in using the Edges API (v1) to manage identities is to synchronize your SaaS users as identities with your Edges workspace.
Here's a quick recap of the ways Edges can adapt to your needs:
1. **White Label** – Fully branded solutions where Edges runs in the background, allowing your brand to take the spotlight.
2. **White Label — Stealth Mode** – Run Edges's API with managed LinkedIn accounts—no Chrome Extension required.
Check out this article for more information: [LinkedIn Identities Options: Sync, Rent, or Use Managed](/v1/identities/sync-vs-managed)
3. **Grey Label** – Combine Edges's Chrome Extension with shared accounts, utilizing our branded Edges connection flow.
**Quick Start Option:** If you want to get started immediately without managing identities and integrations, you can use [Managed Mode](#managed-mode) which uses Edges's pre-configured accounts (1.5× credit cost).
For comprehensive details about identity modes, see [Identity Modes: Direct, Auto, and Managed](/v1/identities/modes).
When integrating your SaaS with Edges, it's important to understand the distinction between **Identities** and **Integrations**.
* **Identities**: Each user on your SaaS corresponds to an identity in Edges. Think of a identity as a **license** that enables automation for that individual.
* **Integrations**: Integrations are the specific integrations (like LinkedIn) attached to an identity, allowing them to run automations on specific platforms.
## **1. Create an Identity**
To enable automation for an Identity, create the identity by sending a **POST** request to the [Create an Identity](/v1/api/identities/create) endpoint:
```bash theme={null}
curl --request POST \
--url https://api.edges.run/v1/identities \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"name": "John Doe or a reference for your identity",
"timezone": "Europe/Paris",
"type": "standard"
}'
```
A name that allows you to identify the Identity: it can be the full name of the Identity or an internal reference (or both!) at your convenience.
The Identity's timezone.
The `timezone` field provisions a proxy IP matching that timezone/country.
This needs to match the location where you log into your LinkedIn account to
avoid restrictions.
Edges supports the [canonical IANA time zones](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones), as defined by the tz database. Only canonical names are accepted. Deprecated or alias entries are currently not supported.
Example: "Europe/Kiev" is deprecated and has been replaced by "Europe/Kyiv", which is the valid canonical identifier. Deprecated names are maintained in the IANA backward zone file for legacy compatibility but should not be used.
When using a VPN, either
1. Log out of your VPN before accessing social media, or
2. Ensure the "timezone" you send matches the country of the VPN IP address.
Specifies the type of identity. Determines billing and credit consumption behavior.
* **`standard`** (default): Standard identity included in your plan. All actions consume credits at the normal rate.
* **`engagement`**: Engagement identity that allows running a broad set of LinkedIn outreach actions (connect, message, follow, like, comment, etc.) **without consuming credits**. Ideal for building SaaS products or AI agents that enable users to engage on LinkedIn or create outreach sequences.
Engagement Identities must be **enabled first** from the [Developer Settings](https://app.edges.run/settings/developers) page and require billing details to be filled. They are **billed monthly** based on the peak number of active Engagement Identities during your billing cycle (starting at \$7.99/identity/month).
Use Engagement Identities for high-volume, repetitive outreach actions (connect, message, follow) and keep standard identities for more occasional or data extraction workflows. See [Engagement Identities](/v1/identities/engagement) for more details.
### **Save the Identity's `uid`**
Once the request is successful, Edges will return an Identity's `uid`.
Save this as `identity_uid` in your own user database - you'll need it for:
* Connecting integrations for this Identity
* Launching actions, via the `identity_ids` field
💡 When launching an action, always pass the Identity's `uid` via the
`identity_ids` field. You do not need to pass the Integration's UID.
### **Identity Modes**
Edges supports three identity modes to control how accounts are used for action execution:
#### **Direct Mode**
Use specific identities for precise control:
```bash theme={null}
curl --request POST \
--url 'https://api.edges.run/v1/actions/linkedin-extract-people/run/live' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"identity_mode": "direct",
"identity_ids": ["identity-1", "identity-2"]
}'
```
#### **Auto Mode**
Automatic distribution across all available accounts:
```bash theme={null}
curl --request POST \
--url 'https://api.edges.run/v1/actions/linkedin-extract-people/run/live' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"identity_mode": "auto"
}'
```
#### **Managed Mode**
Use Edges's pre-configured account pool (1.5× credit cost):
```bash theme={null}
curl --request POST \
--url 'https://api.edges.run/v1/actions/linkedin-extract-people/run/live' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"identity_mode": "managed"
}'
```
**Managed mode cost:** Using `identity_mode: "managed"` costs 1.5× the standard credit cost but requires no setup.
For detailed comparisons and use case recommendations, see [LinkedIn Identities Options: Sync, Rent, or Use Managed](/v1/identities/sync-vs-managed).
## **2. Connect an Identity's Integration**
To run most automations, your identities must be linked to the platform(s) they'll act on, like LinkedIn.
This section walks you through creating an identity and connecting the necessary integrations using Edges's API.
Once you have created an identity, the next step is to attach an integration.
This integration enables the identity to automate specific platforms, like LinkedIn, through Edges.
### **Request Body**
To create or update an integration, use the **POST** method for the
[Connect an Identity's Integration](/v1/api/integrations/connect) endpoint.
Here's an example for a **COOKIES** integration type (like LinkedIn):
```bash theme={null}
curl --request POST \
--url https://api.edges.run/v1/identities/{identity_uid}/integrations/linkedin \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"account_name": "LinkedIn Account #1",
"auth_data": {
"cookies": {
"li_at": "",
"li_a": ""
}
}
}'
```
Name of the LinkedIn account, e.g. "LinkedIn Account #1". It's generally the
User's `full_name` or `email`.
For **COOKIES** integration types, provide authentication cookies here.
**Important note**: If you're connecting an account for **LinkedIn Sales
Navigator**, you need to send both cookies. If you don't include the `li_a`
token, the connection may not work properly with LinkedIn Sales Navigator.
Including the `li_a` token will also speed up account synchronization.
### **Supported Authentication Types**
Edges supports the following integration types:
* **COOKIES**
* **BASIC**
* **OAUTH**
* **APIKEY**
Each type may require a slightly different request body.
### **Native LinkedIn Authentication**
You can also authenticate LinkedIn accounts using email and password credentials. This method uses Edges's native LinkedIn authentication system.
Here's an example request using the [Connect a LinkedIn Account (Username/Password)](/v1/api/linkedin/authentication) endpoint:
```bash theme={null}
curl --request POST \
--url https://api.edges.run/v1/identities/{identity_uid}/integrations/linkedin \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"auth_data": {
"basic": {
"username": "elon@musk.com",
"password": "********"
}
}
}'
```
**Important**: we encrypt everything for security reasons.
### **Native LinkedIn Login Link**
To simplify integration setup for your users, we handle all authentication complexity automatically.
Rather than building custom login forms and managing credentials, we provide secure, time-limited URLs (valid for 48 hours) that enable users to connect their accounts seamlessly.
These login links work with supported integrations like LinkedIn without requiring browser extensions or custom form handling.
When you create an Identity using our [Identity creation endpoint](/v1/api/identities/create), you'll receive these login links in the response:
```json theme={null}
{
"uid": "123e4567-e89b-12d3-a456-426614174000",
"created_at": "2023-10-01T12:00:00Z",
"workspace_uid": "5678e456-e89b-12d3-a456-426614174001",
"name": "John Doe",
"timezone": "Europe/Paris",
"integrations": [],
"identity_login_links": {
"linkedin": "https://app.edges.run/identities/linkedin/login?token=XXXXXX"
}
}
```
You can share the login URL ([https://app.edges.run/identities/linkedin/login?token=XXXXXX](https://app.edges.run/identities/linkedin/login?token=XXXXXX)) via email, or embed it directly in your product interface as a button or link.
When clicked, users are taken to our secure, white-labeled authentication page to complete the LinkedIn connection process.
This feature eliminates the need for browser extensions or custom login forms. Users can securely connect their LinkedIn accounts by simply visiting the provided login link, which works across all browsers and supports all security methods (including SMS, authenticator apps, and in-app confirmations).
If you need to generate new login links (for example, if the previous one expired), you can use the [Generate Login Links](/v1/api/identities/login-links) endpoint.
### Chrome Extension Connection Flow (Grey Label)
An alternative to the native login link is to use Edges's connection flow, which allows you to connect your users' accounts through our Chrome Extension.
Once the identity is created and you have the `identity_uid`, you can generate a connection link that will open the Edges Chrome Extension. The link format is:
`https://app.edges.run/integrations/linkedin/identities/{identity_uid}`
Replace `{identity_uid}` with the actual identity UID you received from the identity creation.
For example, if the identity UID of your new user is `ae369a13-dbd7-493a-bc05-dbbc49ca6c22`, the connection link would look like this:
```plaintext theme={null}
https://app.edges.run/integrations/linkedin/identities/ae369a13-dbd7-493a-bc05-dbbc49ca6c22
```
Share this link with your user, and they will install the Edges Chrome Extension to sync their account. Their LinkedIn account will then be linked to their Edges user.
The shared link is the same as the one you can get on your workspace at [https://app.edges.run/integrations/linkedin](https://app.edges.run/integrations/linkedin) for an existing identity. It will open the Edges Chrome Extension, which will handle the connection process.
To understand the process, you can complete it directly on your workspace. See this step-by-step guide: [https://support.edges.run/en/articles/11588406-how-to-connect-an-identity-to-linkedin](https://support.edges.run/en/articles/11588406-how-to-connect-an-identity-to-linkedin).
# Engagement Identities
Source: https://docs.edges.run/v1/identities/engagement
Learn how to use Engagement Identities to run LinkedIn outreach actions without consuming credits.
## What are Engagement Identities?
**Engagement Identities** are a special type of identity on Edges, allowing you to run a broad set of outreach actions on LinkedIn and Sales Navigator **without consuming credits**.
They are ideal for building SaaS products or AI agents that enable users to engage on LinkedIn or create outreach sequences, while optimizing credit costs at scale.
Engagement Identities must be **enabled first** from the [Developer Settings](https://app.edges.run/settings/developers) page. Billing details must be filled before activation is confirmed.
### Key Benefits
* Access a predefined list of **free outreach actions**
* Keep using all other actions — paid at the normal credit rate
* Create Engagement Identities via UI or API
* Monthly **billing based on peak active Engagement Identities**
* Live feedback on current billing status
### Identity Types Comparison
| | Standard Identity | Engagement Identity |
| -------------------------- | ----------------------- | ------------------- |
| Credit-free outreach | ❌ | ✅ |
| Other actions cost credits | ✅ | ✅ |
| Billed | No *(included in plan)* | Yes *(monthly)* |
| API `type` field | `standard` | `engagement` |
## Pricing & Billing
We invoice **active** Engagement Identities during the month. You are billed based on the **highest number of active Engagement Identities** at any point in your billing cycle (peak), not the total number of Engagement Identities that were ever active.
### When is an Engagement Identity active or inactive?
* **Active** — An Engagement Identity is counted as active when:
* You **add a LinkedIn integration** to it (connect an account), or
* You **call an action** with that identity (e.g. message, connect, extract conversations).
* **Inactive** — An Engagement Identity becomes inactive when:
* It has **not been used in any action** for **30 days**, or
* You **synchronized a LinkedIn account** but have **not called any action** with that identity for **5 days**.
Once inactive, that Engagement Identity no longer counts toward your billed count until it becomes active again (e.g. you run an action with it or connect a new integration).
### How we count: peak of active Engagement Identities
Your monthly charge is based on the **maximum number of active Engagement Identities** you had at the same time during the cycle.
**Example:** You start the month with 5 active Engagement Identities. You add 3 more (8 active). Then 2 become inactive (6 active). You add 2 more (8 active). Later, 3 become inactive (5 active). You are billed for **8** — the highest count of active Engagement Identities during the month — even though 10 Engagement Identities were active at some point.
Engagement Identities are **billed monthly** based on this **peak number of active Engagement Identities** in the billing cycle.
* **Starting at \$7.99/identity/month**
* **Pricing is dynamic**: unit cost decreases as volume increases.
* Pricing details available at [edges.run/pricing?mode=outreach](https://edges.run/pricing?mode=outreach).
### Billing Examples
| Scenario | Current Cycle Billed | Next Cycle Billed |
| -------------------------------------------------------------------------------------- | -------------------- | ----------------- |
| Peak of **10** active Engagement Identities, then you delete all 10 | 10 | 0 |
| Peak of **10** active Engagement Identities, delete 10, recreate 10 (all active again) | 10 | 10 |
| Peak of **3** active Engagement Identities, delete 1, don't recreate | 3 | 2 |
| Peak of **3** active Engagement Identities, delete 1, recreate 1 | 3 | 3 |
## Quick Start
1. **Enable Engagement Identities** in [Developer Settings](https://app.edges.run/settings/developers) and fill billing details
2. **Create an Engagement Identity** via API with `"type": "engagement"`
3. **Connect a LinkedIn account** to your Engagement Identity using the [Connect Integration](/v1/api/integrations/connect) endpoint
4. **Execute actions** — use any of the included actions listed below; they'll run without consuming credits
## Included Actions
The following actions are included for free when executed via an Engagement Identity:
| Action | Endpoint |
| ------------------------------------- | ------------------------------------------------------------------------------------------------ |
| **Connection Actions** | |
| Connect LinkedIn Profile | [`linkedin-connect-profile`](/v1/api/actions/linkedin-connect-profile) |
| Connect Sales Navigator Profile | [`salesnavigator-connect-profile`](/v1/api/actions/salesnavigator-connect-profile) |
| Accept LinkedIn Received Invitations | [`linkedin-accept-invitations`](/v1/api/actions/linkedin-accept-invitations) |
| Withdraw LinkedIn Pending Invitations | [`linkedin-withdraw-invitations`](/v1/api/actions/linkedin-withdraw-invitations) |
| Follow LinkedIn Profile | [`linkedin-follow-profile`](/v1/api/actions/linkedin-follow-profile) |
| **Messaging Actions** | |
| Message LinkedIn Profile | [`linkedin-message-profile`](/v1/api/actions/linkedin-message-profile) |
| Send LinkedIn InMail | [`linkedin-inmail-profile`](/v1/api/actions/linkedin-inmail-profile) |
| Send Sales Navigator InMail | [`salesnavigator-inmail-profile`](/v1/api/actions/salesnavigator-inmail-profile) |
| **Engagement Actions** | |
| Like LinkedIn Post | [`linkedin-like-post`](/v1/api/actions/linkedin-like-post) |
| Comment LinkedIn Post | [`linkedin-comment-post`](/v1/api/actions/linkedin-comment-post) |
| Visit LinkedIn Profile | [`linkedin-visit-profile`](/v1/api/actions/linkedin-visit-profile) |
| Visit Sales Navigator Profile | [`salesnavigator-visit-profile`](/v1/api/actions/salesnavigator-visit-profile) |
| Invite People to LinkedIn Event | [`linkedin-invite-event`](/v1/api/actions/linkedin-invite-event) |
| **Extract Actions** | |
| Extract LinkedIn Connections | [`linkedin-extract-connections`](/v1/api/actions/linkedin-extract-connections) |
| Extract LinkedIn Conversations | [`linkedin-extract-conversations`](/v1/api/actions/linkedin-extract-conversations) |
| Extract LinkedIn Messages | [`linkedin-extract-messages`](/v1/api/actions/linkedin-extract-messages) |
| Extract LinkedIn Followers | [`linkedin-extract-followers`](/v1/api/actions/linkedin-extract-followers) |
| Extract LinkedIn Page Followers | [`linkedin-extract-page-followers`](/v1/api/actions/linkedin-extract-page-followers) |
| Extract LinkedIn Profile Viewers | [`linkedin-extract-profile-viewers`](/v1/api/actions/linkedin-extract-profile-viewers) |
| Extract LinkedIn Received Invitations | [`linkedin-extract-received-invitations`](/v1/api/actions/linkedin-extract-received-invitations) |
| Extract LinkedIn Sent Invitations | [`linkedin-extract-sent-invitations`](/v1/api/actions/linkedin-extract-sent-invitations) |
## Usage Guide
### Requirements & Limitations
* **Account levels matter**: Actions requiring Sales Navigator will only work if the underlying LinkedIn account has proper access.
* The API's global **rate limit** applies (default: 120 req/min).
* A **reasonable usage** is expected to avoid overload for Edges and client platforms. Abuse may result in throttling or degradation.
### API Usage
You can manage Engagement Identities via API using the `type` parameter. See the [Create an Identity](/v1/api/identities/create) endpoint for full request body details.
```bash theme={null}
# Create an Engagement Identity
POST /v1/identities
{
"name": "Sales Outreach Identity",
"timezone": "America/New_York",
"type": "engagement"
}
```
The identity `type` cannot be changed after creation. If you need to switch an identity from `standard` to `engagement` (or vice versa), you must delete the existing identity and create a new one with the desired type.
Each identity response includes a `type` field indicating whether it's `"standard"` or `"engagement"`.
### Monitor Your Usage
You can monitor your monthly Engagement Identity usage directly in the [Identities page](https://app.edges.run/identities) in the Edges dashboard. It shows your current peak of active Engagement Identities and billing forecast for the cycle.
Use Engagement Identities for high-volume, repetitive outreach actions (connect, message, follow) and keep standard identities for more occasional or data extraction workflows.
## Need Help?
Reach out to the Edges team via chat or at [support@edges.run](mailto:support@edges.run) for assistance with activation, billing, or best practices.
# Connecting a LinkedIn Identity
Source: https://docs.edges.run/v1/identities/linkedin
Learn to manage LinkedIn authentication and identity integrations in Edges.
## **Managing LinkedIn Integration**
### **Create a New Identity First**
As a reminder, to automate LinkedIn actions, you must first create an identity in Edges using the
[Create an Identity](/v1/api/identities/create) endpoint. Example request:
```bash theme={null}
curl --request POST \
--url https://api.edges.run/v1/identities \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"name": "John Doe or a reference for your identity",
"timezone": "Europe/Paris",
"type": "standard"
}'
```
A name that allows you to identify the Identity: it can be the full name of the Identity or an internal reference (or both!) at your convenience.
The Identity's timezone.
The `timezone` field provisions a proxy IP matching that timezone/country.
This needs to match the location where you log into your LinkedIn account to
avoid restrictions.
Edges supports the [canonical IANA time zones](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones), as defined by the tz database. Only canonical names are accepted. Deprecated or alias entries are currently not supported.
Example: "Europe/Kiev" is deprecated and has been replaced by "Europe/Kyiv", which is the valid canonical identifier. Deprecated names are maintained in the IANA backward zone file for legacy compatibility but should not be used.
When using a VPN, either
1. Log out of your VPN before accessing social media, or
2. Ensure the "timezone" you send matches the country of the VPN IP address.
Specifies the type of identity. Determines billing and credit consumption behavior.
* **`standard`** (default): Standard identity included in your plan. All actions consume credits at the normal rate.
* **`engagement`**: Engagement identity that allows running a broad set of LinkedIn outreach actions (connect, message, follow, like, comment, etc.) **without consuming credits**. Ideal for building SaaS products or AI agents that enable users to engage on LinkedIn or create outreach sequences.
Engagement Identities must be **enabled first** from the [Developer Settings](https://app.edges.run/settings/developers) page and require billing details to be filled. They are **billed monthly** based on the peak number of active Engagement Identities during your billing cycle (starting at \$7.99/identity/month).
Use Engagement Identities for high-volume, repetitive outreach actions (connect, message, follow) and keep standard identities for more occasional or data extraction workflows. See [Engagement Identities](/v1/identities/engagement) for more details.
### **Connect LinkedIn to Identities**
After adding an Identity, you will [Connect an Identity's Integration](/v1/api/integrations/connect) in order to link the LinkedIn account to the identity.
You can connect LinkedIn accounts in two ways:
1. **Synchronize cookies**: Send LinkedIn authentication cookies (`li_at` and optionally `li_a` for Sales Navigator) to connect an account. This is useful when:
* You already have the cookies from your own Chrome extension
* You want to handle authentication yourself
* You need precise control over cookie management
```bash theme={null}
curl --request POST \
--url https://api.edges.run/v1/identities/{identity_uid}/integrations/linkedin \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"account_name": "LinkedIn Account #1",
"auth_data": {
"cookies": {
"li_at": "",
"li_a": ""
}
}
}'
```
Name of the LinkedIn account, e.g. "LinkedIn Account #1". It's generally the
User's `full_name` or `email`.
For **COOKIES** integration types, provide authentication cookies here.
**Important note**: If you're connecting an account for **LinkedIn Sales
Navigator**, you need to send both cookies. If you don't include the `li_a`
token, the connection may not work properly with LinkedIn Sales Navigator.
Including the `li_a` token will also speed up account synchronization.
2. **Connect natively**: Provide the LinkedIn email and password to let Edges handle the authentication flow. This is recommended when:
* You want a simpler integration
* You don't want to manage cookies
* You need automatic cookie refresh
```bash theme={null}
curl --request POST \
--url https://api.edges.run/v1/identities/{identity_uid}/integrations/linkedin \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"auth_data": {
"basic": {
"username": "elon@musk.com",
"password": "********"
}
}
}'
```
## Monitor LinkedIn Integration Status with Webhooks
LinkedIn integrations have a lifecycle that you can monitor in real-time using webhooks. Whether the integration was created through user interaction, frontend operations, or API calls, webhooks provide instant notifications about status changes.
Webhooks send HTTP requests to your platform when integration events occur, allowing you to:
* **React immediately** to authentication issues
* **Notify users** about account status changes
* **Trigger automated responses** (e.g., resync flows)
* **Monitor integration health** proactively
### Setup Process
Configure a webhook URL in the [developer section of your Edges workspace](https://app.edges.run/settings/developers).
**Webhook URL Requirements:**
* Must be HTTPS (e.g., `https://your-domain.com/webhooks`)
* Supports extended URLs with basic auth, ports, and query parameters (up to 1024 characters)
* Example: `https://user:pass@your-website.com:8080/webhooks/edges/linkedin-integration?foo=bar`
You can also add up to 10 custom headers (e.g., API keys) that will be included with each webhook call.
Each LinkedIn integration event triggers a POST request to your configured URL with this JSON payload:
```json theme={null}
{
"event_uid": "",
"event_type": "integration",
"event": "AUTH_SUCCESS" | "AUTH_PENDING" | "AUTH_FAILED" | "AUTH_EXPIRED" | "AUTH_UPDATED" | "DELETED",
"timestamp": ,
"data": {
"identity_uid": "",
"integration_permalink": "linkedin",
"workspace_uid": "",
"name": null | "",
"level": null | "Classic" | "Sales Navigator" | "Premium" | "Recruiter Lite",
"setup_source": null | "MANUAL" | "EXTENSION" | "SHARED" | "API",
"reason": null | "",
"action_to_be_taken": null | "CONTACT_SUPPORT" | "RETRY_LOGIN" | "RETRY_CHECKPOINT"
}
}
```
##### Field Explanations
| Field | Description |
| --------------------- | -------------------------------------------------------------------------------- |
| `event_type`, `event` | The type and nature of the integration event |
| `data` | Standard integration information (see [API reference](/v1/api/integrations/get)) |
| `reason` | Cause of the event (especially relevant for `AUTH_EXPIRED`) |
| `action_to_be_taken` | Recommended next step for handling the event |
### Event Types
| Event | Description | Typical Action |
| -------------- | --------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
| `AUTH_SUCCESS` | Integration successfully authenticated | Continue normal operations |
| `AUTH_PENDING` | Authentication in progress | Wait for completion |
| `AUTH_FAILED` | Authentication failed | Retry or notify user |
| `AUTH_EXPIRED` | Authentication expired | Trigger resync flow |
| `AUTH_UPDATED` | LinkedIn account level change (Classic, Sales Navigator,...) | Retry or notify user |
| `DELETED` | Integration was removed (for example via [Delete an Identity’s Integration](/v1/api/integrations/delete)) | Remove cached credentials, stop jobs using this integration |
### Use Cases
#### 1. Handle Expired Sessions
When you receive an `AUTH_EXPIRED` event with `action_to_be_taken: "RETRY_LOGIN"`, you can:
* **Trigger immediate resync** via API call
* **Notify users** to re-authenticate
* **Pause dependent workflows** until resolved
#### 2. Monitor Native Login Workflow
When using the [native login workflow](/v1/identities/add-manage-identities#native-linkedin-login-link), users complete authentication asynchronously. The `AUTH_SUCCESS` event confirms when setup is complete.
**Best Practices:**
* Ensure your webhook endpoint handles POST requests and JSON payloads
* Implement proper error handling and logging
* Consider verifying webhook authenticity (e.g., via headers)
* Respond quickly to webhook requests (within 5 seconds)
## **Best Practices for LinkedIn Automation**
**VPN and Timezone/Country Settings**
* Ensure the `timezone` in Edges matches your login location on LinkedIn.
* Match your VPN's country with Edges, or disconnect the VPN while logging in.
### **Supported Timezones & Country Mappings**
Use this JSON array directly in your code for timezone validation or dropdown menus:
```json theme={null}
["Africa/Abidjan", "Africa/Accra", "Africa/Addis_Ababa", "Africa/Algiers", "Africa/Asmara", "Africa/Bamako", "Africa/Bangui", "Africa/Banjul", "Africa/Bissau", "Africa/Blantyre", "Africa/Brazzaville", "Africa/Bujumbura", "Africa/Cairo", "Africa/Casablanca", "Africa/Ceuta", "Africa/Conakry", "Africa/Dakar", "Africa/Dar_es_Salaam", "Africa/Djibouti", "Africa/Douala", "Africa/El_Aaiun", "Africa/Freetown", "Africa/Gaborone", "Africa/Harare", "Africa/Johannesburg", "Africa/Juba", "Africa/Kampala", "Africa/Khartoum", "Africa/Kigali", "Africa/Kinshasa", "Africa/Lagos", "Africa/Libreville", "Africa/Lome", "Africa/Luanda", "Africa/Lubumbashi", "Africa/Lusaka", "Africa/Malabo", "Africa/Maputo", "Africa/Maseru", "Africa/Monrovia", "Africa/Mogadishu", "Africa/Ndjamena", "Africa/Niamey", "Africa/Nouakchott", "Africa/Porto-Novo", "Africa/Sao_Tome", "Africa/Tripoli", "Africa/Tunis", "Africa/Windhoek", "America/Adak", "America/Anchorage", "America/Anguilla", "America/Antigua", "America/Araguaina", "America/Argentina/Buenos_Aires", "America/Argentina/Catamarca", "America/Argentina/Cordoba", "America/Argentina/Jujuy", "America/Argentina/La_Rioja", "America/Argentina/Mendoza", "America/Argentina/Rio_Gallegos", "America/Argentina/Salta", "America/Argentina/San_Juan", "America/Argentina/San_Luis", "America/Argentina/Tucuman", "America/Argentina/Ushuaia", "America/Aruba", "America/Asuncion", "America/Atikokan", "America/Bahia", "America/Bahia_Banderas", "America/Barbados", "America/Belem", "America/Belize", "America/Boa_Vista", "America/Bogota", "America/Boise", "America/Cambridge_Bay", "America/Campo_Grande", "America/Cancun", "America/Caracas", "America/Cayenne", "America/Cayman", "America/Chicago", "America/Chihuahua", "America/Curacao", "America/Danmarkshavn", "America/Dawson", "America/Dawson_Creek", "America/Denver", "America/Detroit", "America/Dominica", "America/Edmonton", "America/Eirunepe", "America/El_Salvador", "America/Fort_Nelson", "America/Fortaleza", "America/Glace_Bay", "America/Goose_Bay", "America/Grand_Turk", "America/Grenada", "America/Guadeloupe", "America/Guatemala", "America/Guayaquil", "America/Guyana", "America/Halifax", "America/Havana", "America/Hermosillo", "America/Indiana/Indianapolis", "America/Indiana/Knox", "America/Indiana/Marengo", "America/Indiana/Petersburg", "America/Indiana/Tell_City", "America/Indiana/Vevay", "America/Indiana/Vincennes", "America/Indiana/Winamac", "America/Inuvik", "America/Iqaluit", "America/Jamaica", "America/Juneau", "America/Kentucky/Louisville", "America/Kentucky/Monticello", "America/Kralendijk", "America/La_Paz", "America/Lima", "America/Los_Angeles", "America/Managua", "America/Manaus", "America/Marigot", "America/Martinique", "America/Matamoros", "America/Mazatlan", "America/Menominee", "America/Merida", "America/Metlakatla", "America/Mexico_City", "America/Miquelon", "America/Moncton", "America/Monterrey", "America/Montevideo", "America/Montserrat", "America/Nassau", "America/New_York", "America/Nipigon", "America/Nome", "America/Noronha", "America/North_Dakota/Beulah", "America/North_Dakota/Center", "America/North_Dakota/New_Salem", "America/Nuuk", "America/Ojinaga", "America/Panama", "America/Paramaribo", "America/Phoenix", "America/Port-au-Prince", "America/Port_of_Spain", "America/Porto_Velho", "America/Puerto_Rico", "America/Punta_Arenas", "America/Rainy_River", "America/Rankin_Inlet", "America/Recife", "America/Regina", "America/Resolute", "America/Rio_Branco", "America/Santiago", "America/Santo_Domingo", "America/Sao_Paulo", "America/Scoresbysund", "America/Sitka", "America/St_Barthelemy", "America/St_Johns", "America/St_Kitts", "America/St_Lucia", "America/St_Thomas", "America/St_Vincent", "America/Swift_Current", "America/Tegucigalpa", "America/Thule", "America/Thunder_Bay", "America/Tijuana", "America/Toronto", "America/Tortola", "America/Vancouver", "America/Whitehorse", "America/Winnipeg", "America/Yakutat", "America/Yellowknife", "Antarctica/Casey", "Antarctica/Davis", "Antarctica/DumontDUrville", "Antarctica/Macquarie", "Antarctica/Mawson", "Antarctica/McMurdo", "Antarctica/Palmer", "Antarctica/Rothera", "Antarctica/Syowa", "Antarctica/Troll", "Antarctica/Vostok", "Arctic/Longyearbyen", "Asia/Aden", "Asia/Almaty", "Asia/Amman", "Asia/Anadyr", "Asia/Aqtau", "Asia/Aqtobe", "Asia/Ashgabat", "Asia/Atyrau", "Asia/Baghdad", "Asia/Bahrain", "Asia/Baku", "Asia/Bangkok", "Asia/Barnaul", "Asia/Beirut", "Asia/Bishkek", "Asia/Brunei", "Asia/Chita", "Asia/Choibalsan", "Asia/Colombo", "Asia/Damascus", "Asia/Dhaka", "Asia/Dili", "Asia/Dubai", "Asia/Dushanbe", "Asia/Famagusta", "Asia/Gaza", "Asia/Hebron", "Asia/Ho_Chi_Minh", "Asia/Hong_Kong", "Asia/Hovd", "Asia/Irkutsk", "Asia/Jakarta", "Asia/Jayapura", "Asia/Jerusalem", "Asia/Kabul", "Asia/Kamchatka", "Asia/Karachi", "Asia/Kathmandu", "Asia/Khandyga", "Asia/Kolkata", "Asia/Krasnoyarsk", "Asia/Kuala_Lumpur", "Asia/Kuching", "Asia/Kuwait", "Asia/Macau", "Asia/Magadan", "Asia/Makassar", "Asia/Manila", "Asia/Muscat", "Asia/Nicosia", "Asia/Novokuznetsk", "Asia/Novosibirsk", "Asia/Omsk", "Asia/Oral", "Asia/Phnom_Penh", "Asia/Pontianak", "Asia/Pyongyang", "Asia/Qatar", "Asia/Qostanay", "Asia/Qyzylorda", "Asia/Riyadh", "Asia/Sakhalin", "Asia/Samarkand", "Asia/Seoul", "Asia/Shanghai", "Asia/Singapore", "Asia/Srednekolymsk", "Asia/Taipei", "Asia/Tashkent", "Asia/Tbilisi", "Asia/Tehran", "Asia/Thimphu", "Asia/Tokyo", "Asia/Tomsk", "Asia/Ulaanbaatar", "Asia/Urumqi", "Asia/Ust-Nera", "Asia/Vientiane", "Asia/Vladivostok", "Asia/Yakutsk", "Asia/Yangon", "Asia/Yekaterinburg", "Asia/Yerevan", "Atlantic/Azores", "Atlantic/Canary", "Atlantic/Cape_Verde", "Atlantic/Faroe", "Atlantic/Madeira", "Atlantic/Reykjavik", "Atlantic/South_Georgia", "Atlantic/St_Helena", "Atlantic/Stanley", "Australia/Adelaide", "Australia/Brisbane", "Australia/Broken_Hill", "Australia/Currie", "Australia/Darwin", "Australia/Eucla", "Australia/Hobart", "Australia/Lindeman", "Australia/Lord_Howe", "Australia/Melbourne", "Australia/Perth", "Australia/Sydney", "Europe/Amsterdam", "Europe/Andorra", "Europe/Astrakhan", "Europe/Athens", "Europe/Belgrade", "Europe/Berlin", "Europe/Bratislava", "Europe/Brussels", "Europe/Bucharest", "Europe/Budapest", "Europe/Busingen", "Europe/Chisinau", "Europe/Copenhagen", "Europe/Dublin", "Europe/Gibraltar", "Europe/Guernsey", "Europe/Helsinki", "Europe/Istanbul", "Europe/Jersey", "Europe/Kaliningrad", "Europe/Kiev", "Europe/Kirov", "Europe/Lisbon", "Europe/Ljubljana", "Europe/London", "Europe/Luxembourg", "Europe/Madrid", "Europe/Mariehamn", "Europe/Minsk", "Europe/Monaco", "Europe/Moscow", "Europe/Oslo", "Europe/Paris", "Europe/Podgorica", "Europe/Prague", "Europe/Riga", "Europe/Rome", "Europe/Samara", "Europe/San_Marino", "Europe/Sarajevo", "Europe/Saratov", "Europe/Simferopol", "Europe/Skopje", "Europe/Sofia", "Europe/Stockholm", "Europe/Tallinn", "Europe/Tirane", "Europe/Ulyanovsk", "Europe/Uzhgorod", "Europe/Vaduz", "Europe/Vatican", "Europe/Vienna", "Europe/Vilnius", "Europe/Volgograd", "Europe/Warsaw", "Europe/Zagreb", "Europe/Zaporozhye", "Europe/Zurich", "Indian/Antananarivo", "Indian/Chagos", "Indian/Christmas", "Indian/Cocos", "Indian/Comoro", "Indian/Kerguelen", "Indian/Mahe", "Indian/Maldives", "Indian/Mauritius", "Indian/Mayotte", "Indian/Reunion", "Pacific/Apia", "Pacific/Auckland", "Pacific/Bougainville", "Pacific/Chatham", "Pacific/Chuuk", "Pacific/Efate", "Pacific/Enderbury", "Pacific/Fakaofo", "Pacific/Fiji", "Pacific/Funafuti", "Pacific/Galapagos", "Pacific/Gambier", "Pacific/Guadalcanal", "Pacific/Guam", "Pacific/Kiritimati", "Pacific/Kosrae", "Pacific/Kwajalein", "Pacific/Majuro", "Pacific/Marquesas", "Pacific/Midway", "Pacific/Nauru", "Pacific/Niue", "Pacific/Norfolk", "Pacific/Noumea", "Pacific/Palau", "Pacific/Pitcairn", "Pacific/Pohnpei", "Pacific/Port_Moresby", "Pacific/Rarotonga", "Pacific/Saipan", "Pacific/Tahiti", "Pacific/Tarawa", "Pacific/Tongatapu", "Pacific/Wake", "Pacific/Wallis"]
```
Edges supports all standard IANA timezones for LinkedIn authentication. Below is the complete list organized by region.
### 🌍 Africa
`Africa/Abidjan`, `Africa/Accra`, `Africa/Addis_Ababa`, `Africa/Algiers`, `Africa/Asmara`, `Africa/Bamako`, `Africa/Bangui`, `Africa/Banjul`, `Africa/Bissau`, `Africa/Blantyre`, `Africa/Brazzaville`, `Africa/Bujumbura`, `Africa/Cairo`, `Africa/Casablanca`, `Africa/Ceuta`, `Africa/Conakry`, `Africa/Dakar`, `Africa/Dar_es_Salaam`, `Africa/Djibouti`, `Africa/Douala`, `Africa/El_Aaiun`, `Africa/Freetown`, `Africa/Gaborone`, `Africa/Harare`, `Africa/Johannesburg`, `Africa/Juba`, `Africa/Kampala`, `Africa/Khartoum`, `Africa/Kigali`, `Africa/Kinshasa`, `Africa/Lagos`, `Africa/Libreville`, `Africa/Lome`, `Africa/Luanda`, `Africa/Lubumbashi`, `Africa/Lusaka`, `Africa/Malabo`, `Africa/Maputo`, `Africa/Maseru`, `Africa/Monrovia`, `Africa/Mogadishu`, `Africa/Ndjamena`, `Africa/Niamey`, `Africa/Nouakchott`, `Africa/Porto-Novo`, `Africa/Sao_Tome`, `Africa/Tripoli`, `Africa/Tunis`, `Africa/Windhoek`
### 🌎 Americas
`America/Adak`, `America/Anchorage`, `America/Anguilla`, `America/Antigua`, `America/Araguaina`, `America/Argentina/Buenos_Aires`, `America/Argentina/Catamarca`, `America/Argentina/Cordoba`, `America/Argentina/Jujuy`, `America/Argentina/La_Rioja`, `America/Argentina/Mendoza`, `America/Argentina/Rio_Gallegos`, `America/Argentina/Salta`, `America/Argentina/San_Juan`, `America/Argentina/San_Luis`, `America/Argentina/Tucuman`, `America/Argentina/Ushuaia`, `America/Aruba`, `America/Asuncion`, `America/Atikokan`, `America/Bahia`, `America/Bahia_Banderas`, `America/Barbados`, `America/Belem`, `America/Belize`, `America/Boa_Vista`, `America/Bogota`, `America/Boise`, `America/Cambridge_Bay`, `America/Campo_Grande`, `America/Cancun`, `America/Caracas`, `America/Cayenne`, `America/Cayman`, `America/Chicago`, `America/Chihuahua`, `America/Curacao`, `America/Danmarkshavn`, `America/Dawson`, `America/Dawson_Creek`, `America/Denver`, `America/Detroit`, `America/Dominica`, `America/Edmonton`, `America/Eirunepe`, `America/El_Salvador`, `America/Fort_Nelson`, `America/Fortaleza`, `America/Glace_Bay`, `America/Goose_Bay`, `America/Grand_Turk`, `America/Grenada`, `America/Guadeloupe`, `America/Guatemala`, `America/Guayaquil`, `America/Guyana`, `America/Halifax`, `America/Havana`, `America/Hermosillo`, `America/Indiana/Indianapolis`, `America/Indiana/Knox`, `America/Indiana/Marengo`, `America/Indiana/Petersburg`, `America/Indiana/Tell_City`, `America/Indiana/Vevay`, `America/Indiana/Vincennes`, `America/Indiana/Winamac`, `America/Inuvik`, `America/Iqaluit`, `America/Jamaica`, `America/Juneau`, `America/Kentucky/Louisville`, `America/Kentucky/Monticello`, `America/Kralendijk`, `America/La_Paz`, `America/Lima`, `America/Los_Angeles`, `America/Managua`, `America/Manaus`, `America/Marigot`, `America/Martinique`, `America/Matamoros`, `America/Mazatlan`, `America/Menominee`, `America/Merida`, `America/Metlakatla`, `America/Mexico_City`, `America/Miquelon`, `America/Moncton`, `America/Monterrey`, `America/Montevideo`, `America/Montserrat`, `America/Nassau`, `America/New_York`, `America/Nipigon`, `America/Nome`, `America/Noronha`, `America/North_Dakota/Beulah`, `America/North_Dakota/Center`, `America/North_Dakota/New_Salem`, `America/Nuuk`, `America/Ojinaga`, `America/Panama`, `America/Paramaribo`, `America/Phoenix`, `America/Port-au-Prince`, `America/Port_of_Spain`, `America/Porto_Velho`, `America/Puerto_Rico`, `America/Punta_Arenas`, `America/Rainy_River`, `America/Rankin_Inlet`, `America/Recife`, `America/Regina`, `America/Resolute`, `America/Rio_Branco`, `America/Santiago`, `America/Santo_Domingo`, `America/Sao_Paulo`, `America/Scoresbysund`, `America/Sitka`, `America/St_Barthelemy`, `America/St_Johns`, `America/St_Kitts`, `America/St_Lucia`, `America/St_Thomas`, `America/St_Vincent`, `America/Swift_Current`, `America/Tegucigalpa`, `America/Thule`, `America/Thunder_Bay`, `America/Tijuana`, `America/Toronto`, `America/Tortola`, `America/Vancouver`, `America/Whitehorse`, `America/Winnipeg`, `America/Yakutat`, `America/Yellowknife`
### 🌏 Antarctica
`Antarctica/Casey`, `Antarctica/Davis`, `Antarctica/DumontDUrville`, `Antarctica/Macquarie`, `Antarctica/Mawson`, `Antarctica/McMurdo`, `Antarctica/Palmer`, `Antarctica/Rothera`, `Antarctica/Syowa`, `Antarctica/Troll`, `Antarctica/Vostok`
### 🌐 Arctic
`Arctic/Longyearbyen`
### 🌏 Asia
`Asia/Aden`, `Asia/Almaty`, `Asia/Amman`, `Asia/Anadyr`, `Asia/Aqtau`, `Asia/Aqtobe`, `Asia/Ashgabat`, `Asia/Atyrau`, `Asia/Baghdad`, `Asia/Bahrain`, `Asia/Baku`, `Asia/Bangkok`, `Asia/Barnaul`, `Asia/Beirut`, `Asia/Bishkek`, `Asia/Brunei`, `Asia/Chita`, `Asia/Choibalsan`, `Asia/Colombo`, `Asia/Damascus`, `Asia/Dhaka`, `Asia/Dili`, `Asia/Dubai`, `Asia/Dushanbe`, `Asia/Famagusta`, `Asia/Gaza`, `Asia/Hebron`, `Asia/Ho_Chi_Minh`, `Asia/Hong_Kong`, `Asia/Hovd`, `Asia/Irkutsk`, `Asia/Jakarta`, `Asia/Jayapura`, `Asia/Jerusalem`, `Asia/Kabul`, `Asia/Kamchatka`, `Asia/Karachi`, `Asia/Kathmandu`, `Asia/Khandyga`, `Asia/Kolkata`, `Asia/Krasnoyarsk`, `Asia/Kuala_Lumpur`, `Asia/Kuching`, `Asia/Kuwait`, `Asia/Macau`, `Asia/Magadan`, `Asia/Makassar`, `Asia/Manila`, `Asia/Muscat`, `Asia/Nicosia`, `Asia/Novokuznetsk`, `Asia/Novosibirsk`, `Asia/Omsk`, `Asia/Oral`, `Asia/Phnom_Penh`, `Asia/Pontianak`, `Asia/Pyongyang`, `Asia/Qatar`, `Asia/Qostanay`, `Asia/Qyzylorda`, `Asia/Riyadh`, `Asia/Sakhalin`, `Asia/Samarkand`, `Asia/Seoul`, `Asia/Shanghai`, `Asia/Singapore`, `Asia/Srednekolymsk`, `Asia/Taipei`, `Asia/Tashkent`, `Asia/Tbilisi`, `Asia/Tehran`, `Asia/Thimphu`, `Asia/Tokyo`, `Asia/Tomsk`, `Asia/Ulaanbaatar`, `Asia/Urumqi`, `Asia/Ust-Nera`, `Asia/Vientiane`, `Asia/Vladivostok`, `Asia/Yakutsk`, `Asia/Yangon`, `Asia/Yekaterinburg`, `Asia/Yerevan`
### 🌊 Atlantic
`Atlantic/Azores`, `Atlantic/Canary`, `Atlantic/Cape_Verde`, `Atlantic/Faroe`, `Atlantic/Madeira`, `Atlantic/Reykjavik`, `Atlantic/South_Georgia`, `Atlantic/St_Helena`, `Atlantic/Stanley`
### 🦘 Australia
`Australia/Adelaide`, `Australia/Brisbane`, `Australia/Broken_Hill`, `Australia/Currie`, `Australia/Darwin`, `Australia/Eucla`, `Australia/Hobart`, `Australia/Lindeman`, `Australia/Lord_Howe`, `Australia/Melbourne`, `Australia/Perth`, `Australia/Sydney`
### 🌍 Europe
`Europe/Amsterdam`, `Europe/Andorra`, `Europe/Astrakhan`, `Europe/Athens`, `Europe/Belgrade`, `Europe/Berlin`, `Europe/Bratislava`, `Europe/Brussels`, `Europe/Bucharest`, `Europe/Budapest`, `Europe/Busingen`, `Europe/Chisinau`, `Europe/Copenhagen`, `Europe/Dublin`, `Europe/Gibraltar`, `Europe/Guernsey`, `Europe/Helsinki`, `Europe/Istanbul`, `Europe/Jersey`, `Europe/Kaliningrad`, `Europe/Kiev`, `Europe/Kirov`, `Europe/Lisbon`, `Europe/Ljubljana`, `Europe/London`, `Europe/Luxembourg`, `Europe/Madrid`, `Europe/Mariehamn`, `Europe/Minsk`, `Europe/Monaco`, `Europe/Moscow`, `Europe/Oslo`, `Europe/Paris`, `Europe/Podgorica`, `Europe/Prague`, `Europe/Riga`, `Europe/Rome`, `Europe/Samara`, `Europe/San_Marino`, `Europe/Sarajevo`, `Europe/Saratov`, `Europe/Simferopol`, `Europe/Skopje`, `Europe/Sofia`, `Europe/Stockholm`, `Europe/Tallinn`, `Europe/Tirane`, `Europe/Ulyanovsk`, `Europe/Uzhgorod`, `Europe/Vaduz`, `Europe/Vatican`, `Europe/Vienna`, `Europe/Vilnius`, `Europe/Volgograd`, `Europe/Warsaw`, `Europe/Zagreb`, `Europe/Zaporozhye`, `Europe/Zurich`
### 🌴 Indian Ocean
`Indian/Antananarivo`, `Indian/Chagos`, `Indian/Christmas`, `Indian/Cocos`, `Indian/Comoro`, `Indian/Kerguelen`, `Indian/Mahe`, `Indian/Maldives`, `Indian/Mauritius`, `Indian/Mayotte`, `Indian/Reunion`
### 🏝️ Pacific
`Pacific/Apia`, `Pacific/Auckland`, `Pacific/Bougainville`, `Pacific/Chatham`, `Pacific/Chuuk`, `Pacific/Efate`, `Pacific/Enderbury`, `Pacific/Fakaofo`, `Pacific/Fiji`, `Pacific/Funafuti`, `Pacific/Galapagos`, `Pacific/Gambier`, `Pacific/Guadalcanal`, `Pacific/Guam`, `Pacific/Kiritimati`, `Pacific/Kosrae`, `Pacific/Kwajalein`, `Pacific/Majuro`, `Pacific/Marquesas`, `Pacific/Midway`, `Pacific/Nauru`, `Pacific/Niue`, `Pacific/Norfolk`, `Pacific/Noumea`, `Pacific/Palau`, `Pacific/Pitcairn`, `Pacific/Pohnpei`, `Pacific/Port_Moresby`, `Pacific/Rarotonga`, `Pacific/Saipan`, `Pacific/Tahiti`, `Pacific/Tarawa`, `Pacific/Tongatapu`, `Pacific/Wake`, `Pacific/Wallis`
The JSON object below shows which countries share IP allocations. This is useful for understanding which neighboring countries can be used as alternatives if your primary timezone is not available.
**Usage:** If your primary timezone is not available, you can use any of the countries listed in the array for that country code as an alternative.
```json theme={null}
{
"af": ["pk", "ir", "tm", "cn", "uz", "tj"],
"al": ["me", "mk", "gr", "xk", "it", "rs"],
"dz": ["ma", "tn", "ly", "ne", "ml", "mr"],
"as": ["us", "ki", "fm", "pg", "to", "ws"],
"ad": ["fr", "es"],
"ao": ["zm", "na", "cg", "cd", "tz"],
"ar": ["cl", "py", "bo", "br", "uy"],
"au": ["fj", "pg", "ws", "ki", "nz"],
"at": ["de", "cz", "hu", "si", "it", "ch"],
"az": ["am", "ge", "ru", "tr", "ir"],
"bs": ["us", "cu", "ht", "do", "jm"],
"bh": ["sa", "qa", "ae"],
"bd": ["in", "mm", "np"],
"bb": ["vc", "tt", "lc", "gd"],
"by": ["ru", "ua", "pl", "lt", "lv"],
"be": ["fr", "de", "nl", "lu", "gb"],
"bz": ["gt", "mx", "hn", "sv"],
"bj": ["ne", "ng", "tg", "gh", "bf", "ml"],
"bt": ["in", "cn"],
"bo": ["ar", "cl", "py", "pe", "br"],
"ba": ["hr", "me", "rs", "si", "mk"],
"bw": ["za", "zm", "na"],
"br": ["ar", "bo", "co", "gy", "pe", "sr", "uy", "ve"],
"bn": ["my", "id"],
"bg": ["ro", "rs", "mk", "gr", "tr", "ua"],
"bf": ["ne", "ml", "ci", "gh", "tg", "bj"],
"bi": ["rw", "tz", "ug", "cd"],
"kh": ["vn", "la", "th"],
"cm": ["ng", "gq", "ga", "cf", "td", "cg"],
"ca": ["us"],
"cv": ["sn", "gm", "mr"],
"ky": ["jm", "cu"],
"cf": ["cm", "td", "sd", "cg", "cd", "ss"],
"ch": ["fr", "de", "it", "at", "li"],
"cl": ["ar", "bo", "pe"],
"cn": ["mn", "np", "in", "pk", "af", "tj", "kg", "kz", "ru", "la", "vn", "kp"],
"co": ["pa", "ve", "ec", "pe", "br"],
"km": ["mg", "tz", "mz"],
"cd": ["cg", "cf", "ss", "ug", "rw", "bi", "tz", "zm", "ao"],
"cg": ["cd", "cf", "cm", "ga"],
"cr": ["ni", "pa"],
"ci": ["gh", "bf", "ml", "lr", "gn"],
"hr": ["si", "hu", "rs", "ba", "me"],
"cu": ["jm", "ht", "do"],
"cy": ["tr", "gr", "sy", "lb", "il"],
"cz": ["de", "pl", "sk", "at"],
"dk": ["de", "se", "no"],
"dj": ["er", "et", "so"],
"dm": ["gd", "mq", "lc"],
"do": ["ht", "cu", "jm"],
"ec": ["co", "pe"],
"eg": ["ly", "sd", "il", "ps"],
"sv": ["gt", "hn"],
"gq": ["cm", "cg", "ga"],
"er": ["sd", "et", "dj"],
"ee": ["fi", "ru", "lv"],
"et": ["er", "sd", "dj", "so", "ke", "ss"],
"fo": ["is", "no", "dk"],
"fj": ["au", "ws", "to", "ki", "sb"],
"fi": ["se", "no", "ru"],
"fr": ["be", "ch", "es", "lu", "de", "ad", "it", "mc"],
"ga": ["cm", "cg", "gq"],
"gb": ["ie", "fr", "be", "nl"],
"gh": ["ci", "tg", "bf", "ng"],
"gn": ["sn", "ci", "ml", "lr", "sl", "gw"],
"gm": ["sn"],
"gw": ["gn", "sn"],
"gt": ["mx", "bz", "hn", "sv"],
"gy": ["br", "ve", "sr"],
"hk": ["cn"],
"hn": ["sv", "gt", "ni"],
"ht": ["do", "cu"],
"hu": ["at", "ro", "rs", "sk", "cz", "ua"],
"id": ["my", "tl", "pg"],
"in": ["np", "bd", "mm", "cn", "pk", "bt"],
"ir": ["tr", "az", "tm", "af", "pk", "iq"],
"iq": ["ir", "sy", "jo", "sa", "tr", "kw"],
"ie": ["gb"],
"il": ["ps", "jo", "sy", "lb", "eg"],
"it": ["ch", "fr", "at", "si", "sm", "va"],
"jm": ["cu", "ht", "do"],
"jo": ["sy", "iq", "sa", "il"],
"jp": ["kr", "ru", "cn"],
"kz": ["ru", "cn", "kg", "uz", "tj", "tm"],
"ke": ["et", "so", "ug", "tz", "ss"],
"kg": ["kz", "cn", "tj", "uz"],
"kr": ["kp"],
"kw": ["sa", "iq"],
"la": ["th", "mm", "vn", "cn"],
"lb": ["sy", "il"],
"ls": ["za"],
"lt": ["lv", "pl", "by", "ru"],
"lu": ["fr", "be", "de"],
"lv": ["ee", "lt", "by", "ru"],
"ly": ["eg", "tn", "dz", "td", "ne", "sd"],
"ma": ["dz", "es"],
"mc": ["fr"],
"md": ["ua", "ro"],
"mk": ["al", "gr", "bg", "rs", "xk"],
"mg": ["km", "yt", "mu"],
"mv": ["in", "lk"],
"ml": ["dz", "ci", "bf", "ne", "sn", "gn"],
"mm": ["bd", "th", "la", "cn", "in"],
"mt": ["it", "tn", "ly"],
"mh": ["fm", "pw", "ki"],
"mq": ["gd", "lc", "dm"],
"mr": ["dz", "sn", "ml"],
"mu": ["mg", "sc", "re"],
"mw": ["tz", "zm", "mz"],
"mx": ["us", "gt", "bz"],
"my": ["th", "sg", "id", "bn"],
"mz": ["tz", "mw", "zw", "za", "sz"],
"na": ["za", "bw", "zm", "ao"],
"ne": ["dz", "ml", "bf", "bj", "ng", "td", "ly"],
"ng": ["bj", "ne", "cm", "td"],
"ni": ["hn", "cr"],
"nl": ["be", "de"],
"no": ["se", "fi", "ru"],
"np": ["in", "cn"],
"nz": ["au", "fj", "to"],
"om": ["ae", "sa", "ye"],
"pk": ["in", "af", "ir", "cn"],
"pa": ["cr", "co"],
"pe": ["cl", "bo", "ec", "br", "co"],
"ph": ["my", "id", "vn"],
"pl": ["de", "cz", "sk", "lt", "by", "ua"],
"pt": ["es"],
"qa": ["sa", "bh", "ae"],
"ro": ["ua", "hu", "bg", "rs", "md"],
"ru": ["no", "fi", "ee", "lv", "lt", "pl", "by", "ua", "ge", "az", "kz", "mn", "cn", "kp"],
"rw": ["tz", "ug", "cd", "bi"],
"sa": ["jo", "iq", "kw", "ae", "om", "ye"],
"sb": ["pg", "fj", "vu"],
"sc": ["mu", "km", "re"],
"sd": ["eg", "ly", "td", "er", "et", "ss", "cf"],
"se": ["no", "fi", "dk"],
"sg": ["my"],
"si": ["at", "hu", "hr", "it"],
"sk": ["cz", "pl", "hu", "at", "ua"],
"sl": ["gn", "lr", "ci"],
"sn": ["gm", "gn", "gw", "ml", "mr"],
"so": ["et", "ke", "dj"],
"sr": ["gy", "br"],
"ss": ["sd", "et", "ug", "cd", "cf", "ke"],
"st": ["ga", "cm", "gq"],
"sy": ["lb", "jo", "iq", "tr", "il"],
"sz": ["za", "mz"],
"td": ["ly", "sd", "cf", "cm", "ng", "ne"],
"tg": ["gh", "ci", "bf", "bj"],
"th": ["la", "mm", "kh", "my"],
"tj": ["kg", "uz", "af", "cn"],
"tl": ["id", "au"],
"tm": ["af", "ir", "uz", "kz"],
"tn": ["dz", "ly"],
"tr": ["gr", "bg", "ge", "am", "az", "sy", "iq", "ir"],
"tt": ["ve", "gd"],
"tv": ["fj", "ws", "ki"],
"tz": ["ug", "ke", "rw", "bi", "zm", "mw", "mz"],
"ua": ["ru", "pl", "by", "hu", "ro", "md"],
"ug": ["ke", "tz", "ss", "cd", "rw"],
"us": ["ca", "mx"],
"uy": ["ar", "br"],
"uz": ["kz", "kg", "tj", "af", "tm"],
"va": ["it"],
"ve": ["br", "co", "gy"],
"vn": ["la", "cn", "kh"],
"vu": ["nc", "sb", "fj"],
"ws": ["fj", "to", "tv"],
"ye": ["sa", "om"],
"za": ["na", "bw", "zw", "mz", "ls", "sz"],
"zm": ["ao", "cd", "tz", "mw", "bw", "na", "zw"],
"zw": ["za", "mz", "zm", "bw"]
}
```
### **Managing Chrome Sessions**
* Use Edges's Chrome Extension to automatically sync cookies, useful for testing purposes.
* If you're using multiple LinkedIn accounts on the same browser, you must create separate Chrome profiles:
* Click your Chrome profile icon > **Add** a new profile.
* Name it according to the LinkedIn account (e.g., "Account B").
* Log in to Edges and LinkedIn within this new session.
Updating cookies for Account A while logged into Account B can lead to
mismatches and errors.
### **Refreshing Cookies**
Cookies need refreshing if:
* You log out of LinkedIn
* LinkedIn expires or changes cookies
* LinkedIn restricts the account due to excessive activity
Regular activity and following [**Smart Limits**](/v1/linkedin/limits) guidelines help prevent restrictions.
#### How to refresh cookies via API
To refresh accounts via API, use the [Connect an Identity's Integration](/v1/api/integrations/connect) endpoint by
passing the updated `li_at` and/or `li_a` cookie values:
If you build your own Chrome Extension, you should refresh cookies every 2
hours or so.
Here's a code example for a Chrome Extension that runs in the background using `alarms`:
```jsx theme={null}
/**
* Alarm to update cookies every X minutes.
*/
chrome.alarms.onAlarm.addListener(() => {
// Ensure updateTokensHandle() is defined elsewhere in your code
return updateTokensHandle();
});
// Set up the alarm when the extension is installed
chrome.runtime.onInstalled.addListener(async ({ reason }) => {
const periodDurationMinutes = 120; // Every 2 hours
// Create an alarm that will trigger every `periodDurationMinutes`
await chrome.alarms.create("updateToken", {
periodInMinutes: periodDurationMinutes,
});
console.log(
"Alarm created to update token every " + periodDurationMinutes + " minutes"
);
});
```
Complete source code is available on
[GitHub](https://github.com/edgesrun/chrome-extension-skeleton).
## **Smart Limits to Prevent Restrictions**
Edges developed a unique **Smart Limits** feature to protect your
users' LinkedIn accounts. Learn more in this article [LinkedIn Rate
Limits](/v1/linkedin/limits).
## **LinkedIn Licenses Compatibility**
Edges supports various LinkedIn licenses, each with unique features and limitations. Below is a breakdown of how each license integrates with Edges:
| **License** | **Edges Level** | **Edges Compatibility** | **InMails/Month** | **Invitations with Note** | **CRM Integration** |
| ----------------------------- | --------------- | ----------------------- | ----------------- | ------------------------- | ------------------- |
| **LinkedIn Basic** | Classic | ✅ Yes | 0 | 5/month | No |
| **LinkedIn Premium Career** | Classic | ❌ No | 5 | N/A | No |
| **LinkedIn Premium Business** | Premium | ✅ Yes | 15 | 400 | No |
| **Sales Navigator Core** | Sales Navigator | ✅ Yes | 50 | 400 | No |
Today Edges handles LinkedIn Basic, LinkedIn Premium Business, and Sales Navigator Core which are defined as `level` in the LinkedIn integration.
By following this guide, you can safely automate LinkedIn activities with Edges, ensuring stable sessions and avoiding platform restrictions.
For further assistance, feel free to reach out to our support team at [support@edges.run](mailto:support@edges.run) 🙌
## **Troubleshooting LinkedIn Login Errors**
When connecting a LinkedIn account natively (using username and password), you may encounter various errors. Below is a comprehensive guide to the most common error cases, their meanings, and how to resolve them.
### **Common Error Cases**
When using our native LinkedIn connection module (username and password), you may encounter various errors. Below is a comprehensive guide to the most common error cases, their meanings, and how to resolve them.
| **Scenario** | **Message** | **Status** | **Error** |
| :--------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Invalid credentials | Username or password invalid. | 400 | `INVALID_CREDENTIALS`
Double-check your LinkedIn username and password.
[See authentication endpoint](/v1/api/linkedin/authentication) |
| Password reset needed | The account is locked, you need to request a password reset. | 424 | `REQUEST_PASSWORD_RESET`
Request a password reset on LinkedIn. |
| Google login not supported | Username or password invalid. | 400 | `INVALID_CREDENTIALS`
Google login is not supported.
Use "Forgot password" on LinkedIn to set a password and use that for login. |
| Checkpoint code invalid | Code invalid. | 400 | `INVALID_CODE`
The checkpoint (2FA/SMS/email) code is incorrect. Try again.
[See checkpoint endpoint](/v1/api/linkedin/checkpoint) |
| In-app challenge pending | Waiting for user to validate in\_app\_challenge | 500 | `IN_APP_CHALLENGE_PENDING`
Complete the challenge in your LinkedIn app. |
| In-app challenge expired | In\_app\_challenge expired. Please retry the whole process by sending credentials again on /authenticate | 500 | `IN_APP_CHALLENGE_EXPIRED`
Start the login process again. |
| 2FA expired | 2FA expired. Please retry the whole process by sending credentials again on /authenticate | 500 | `2FA_VALIDATION_EXPIRED`
Start the login process again. |
| Failed IP attribution | Could not login the account. | 500 | `LOGIN_ACCOUNT_500_ERROR`
Retry logging in. This is a LinkedIn-side issue. |
| IP allocation error | IP allocation error. Please retry again in 5 minutes or contact support. | 400 | `IP_ATTRIBUTION_ERROR_400`
Wait 5 minutes and try again, or contact support. |
| IP allocation conflict | IP allocation error. Please retry again in 5 minutes or contact support. | 409 | `IP_ATTRIBUTION_CONFLICT_409`
Wait 5 minutes and try again, or contact support. |
| IP rate limit exceeded | Rate limit exceeded IP attribution, please try again in five (5) minutes or contact the support. | 429 | `IP_ATTRIBUTION_RATE_LIMIT_429`
Wait 5 minutes and try again, or contact support. |
| No IP available in timezone | No IP available in this timezone. Update your timezone to a neighbouring one or contact support. | 400 | `IP_TIMEZONE_NOT_SUPPORTED_400`
Change your timezone in Edges or contact support. |
| Captcha challenge | Error while resolving the challenge, the Captcha challenge seem to be pending. Re-send username and password to overcome this. | 500 | `CAPTCHA_CHALLENGE_ERROR`
Retry the authentication with your credentials. |
| Unsupported challenge | Unsupported challenge identified, please contact the support and provide it with the identity\_uid so we can address it. | 500 | `UNSUPPORTED_CHALLENGE`
Contact support with your identity\_uid. |
| Simple challenge failed | Error while solving challenge, retry in 5 minutes, if it persists contact support. | 500 | `LOGIN_SIMPLE_CHALLENGE`
Wait and retry, or contact support. |
| Checkpoint missing data | Error while solving the challenge, retry the whole process by sending credentials to /authenticate again | 500 | `CHECKPOINT_MISSING_DATA`
Start the login process again. |
| User management not permitted | User management via the API is not permitted for the current workspace, activate the option on [settings](https://app.edges.run/settings/users/parameters) | 403 | `CREATE-ONE-ACCOUNT_403_FORBIDDEN`
Enable user management in your workspace settings. |
| Identity already exists | An identity with the same Linkedin ID already exists. | 409 | `CREATE_OR_UPDATE_ACCOUNT_409_CONFLICT`
Use a different LinkedIn account or identity. |
| Account already exists on identity | An account already exist on this identity | 409 | `CREATE_OR_UPDATE_ACCOUNT_409_CONFLICT`
This will be merged in the future. |
| Account link change | Please note that your LinkedIn integration is different from the one that has already been synchronized on this identity. | 409 | `CREATE_OR_UPDATE_ACCOUNT_409_CONFLICT`
Use the same LinkedIn account as previously connected. |
| Other errors | Error while synchronizing your account, please retry again or contact the support. | 500 | -
Retry or contact support. |
### **Notes & Recommendations**
* **Google Login:** If your LinkedIn account uses Google login, you must set a password on LinkedIn (via "Forgot password") to use native login.
* **IP/Location Issues:** Many errors are related to IP allocation or location mismatches. Make sure your timezone and country settings in Edges match your actual login location.
* **Challenge/2FA:** If you receive a challenge (SMS, email, in-app), complete it promptly. If it expires, restart the login process.
* **Contact Support:** For persistent or unclear errors, contact support and provide your `identity_uid` for faster resolution.
For more details, see the [LinkedIn authentication](/v1/api/linkedin/authentication) and [checkpoint](/v1/api/linkedin/checkpoint) API documentation.
# Overview of Identity Modes
Source: https://docs.edges.run/v1/identities/modes
Learn how to control account usage with direct, auto, and managed identity modes.
Identity modes control how Edges uses your integration accounts when executing actions. You can choose between three modes depending on your needs for control, automation, and cost.
## Available Identity Modes
The identity mode to use: `direct`, `auto`, or `managed`
Array of specific identity IDs to use (required for `direct` mode only)
## Mode Comparison
| Mode | Control Level | Setup Required | Cost | Best For |
| ----------- | ---------------------- | ------------------ | ------------- | ----------------------------- |
| **Direct** | Full control | Manual selection | Standard | Specific accounts, compliance |
| **Auto** | Automatic distribution | Configure accounts | Standard | High-volume, resilience |
| **Managed** | No account management | None | 1.5x standard | Hassle-free automation |
**Managed mode cost:** Using `managed` identity mode costs **1.5×** the standard credit cost for all actions. Calculate your costs with: `current_cost x1.5`.
## Direct Mode
**Full control over which accounts to use**
Use `direct` mode when you need precise control over which integration accounts execute your actions.
### Use Cases
* Actions requiring specific accounts (e.g., [`linkedin-extract-profile-viewers`](/v1/api/actions/linkedin-extract-profile-viewers))
* Using only a subset of your identities (e.g., sales team accounts only)
* Separating company-level calls from user-specific calls
* Compliance requirements for account attribution
### Implementation
```json theme={null}
{
"identity_mode": "direct",
"identity_ids": ["identity-1", "identity-2", "identity-3"]
}
```
### Example Request
```bash theme={null}
curl --request POST \
--url https://api.edges.run/v1/actions/linkedin-extract-profile-viewers/run/live \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"parameters": {},
"identity_mode": "direct",
"identity_ids": ["id-1", "id-2", "id-3"]
}'
```
In `direct` mode, actions are rotated among the specified identities, with priority given to the identity that has been used the least (lowest usage).
Edges will filter out accounts that aren't valid for the current action. For example, using LinkedIn identity IDs for a Sales Navigator action will result in a `NO_VALID_ACCOUNT_CONFIGURED` error.
You must provide at least one valid identity ID when using `direct` mode.
## Auto Mode
**Automatic distribution across all available accounts**
Use `auto` mode for automatic load balancing across all your valid integration accounts.
### Use Cases
* Processing large batches of inputs
* Running parallel actions for better performance
* Actions with strict rate limits (visits, connections)
* Building resilient systems that continue working if some accounts become invalid
### Implementation
```json theme={null}
{
"identity_mode": "auto"
}
```
You still need to configure identities and integration accounts yourself. Ensure you have at least one account with the right integration and subscription level for the action.
If you use `auto` and `identity_ids`, we internally switch to direct (since you’re explicitly selecting identities)
## Managed Mode
**Hassle-free automation with Edges's managed accounts**
Use `managed` mode to execute actions without managing any integration accounts yourself.
### Benefits
* **No account setup required** - Works even without any integration accounts
* **Automatic load distribution** - Optimal performance and parallelism
* **No restrictions** - Avoid rate limits and account issues
* **Simplified workflow** - Focus on your business logic, not account management
### Implementation
```json theme={null}
{
"identity_mode": "managed"
}
```
**Limitation:** You cannot use `managed` mode for actions that require specific accounts (e.g., [`linkedin-extract-profile-viewers`](/v1/api/actions/linkedin-extract-profile-viewers)). For these actions, use `direct` mode with the specific account that owns the data.
**Cost consideration:** Managed mode uses Edges's account pool and costs **1.5x** the standard credit cost for all actions.
# LinkedIn Identities Options: Sync, Rent, or Use Managed
Source: https://docs.edges.run/v1/identities/sync-vs-managed
Choose between syncing your users' LinkedIn accounts, renting accounts, or using managed identities
Edges offers three different approaches for LinkedIn account management, each suited for different use cases and requirements.
## Three Options Overview
| Option | Description | Cost | Best For | Setup Required |
| ---------------------- | ------------------------------------- | -------------------------- | --------------------------------------------- | ----------------------------------- |
| **Sync Your Users'** | Connect your users' LinkedIn accounts | Standard credits | User-specific outreach, personal accounts | Chrome Extension + user setup |
| **Rent Accounts** | Use Edges's managed accounts | \$70-125/month per account | High-volume operations, no user accounts | Request through Edges |
| **Managed Identities** | Use Edges's managed account pool | 1.5x standard credits | Hassle-free automation, no account management | Just set `identity_mode: "managed"` |
## Option 1: Sync Your Users' LinkedIn Accounts
Connect your users' personal LinkedIn accounts using our Chrome Extension, native LinkedIn login, or by providing cookies.
### When to Use
* **User-specific outreach** - Your users sending messages, invitations, InMails
* **Personal account data** - Extracting users' own profile viewers, connections
* **Compliance requirements** - Need to use specific user accounts
* **Cost-sensitive operations** - Standard credit pricing
### Setup Process
1. Choose connection method:
* **Chrome Extension**: Install the [Edges Chrome Extension](/v1/linkedin/chrome-extension)
* **Native Login**: Use [LinkedIn Authentication](/v1/api/linkedin/authentication) for direct login
* **Custom Extension/Cookies**: Use [Connect an Identity's Integration](/v1/api/integrations/connect) with your own cookies
2. Your users connect their LinkedIn accounts through the chosen method
3. Use `identity_mode: "direct"` with your users' account IDs
### Limitations
* Requires setup for each user (extension, native login, or cookie management)
* User account management: cookies, timezones, limits \[...]
## Option 2: Rent LinkedIn Accounts
Use Edges's provisioned LinkedIn accounts for high-volume operations. These accounts are provisioned through third-party accredited services.
### When to Use
* **High-volume data extraction** - Profile enrichment, search data
* **No user accounts available** - Don't want to use your users' accounts
* **Public + anonymized extraction** - No Chrome Extension required
* **B2B services** - Reselling data extraction to your customers
### How to Rent Accounts
1. Go to [LinkedIn Integration Page](https://app.edges.run/integrations/linkedin)
2. Click **"Request a LinkedIn Integration"**
3. Fill out the form and submit your request
4. Receive email confirmation from [support@edges.run](mailto:support@edges.run)
Use your own email for the request—we cannot provide accounts without email confirmation.
### Account Capacity & Rotation
* **1 provisioned account** = 10,000 profile enrichments per day
* **Account Rotation**: Use `identity_mode: "auto"` for automatic load distribution
* **Timeline**: 24-48 hours for \< 10 accounts, 3-5 days for larger requests
#### Example: Enable Account Rotation
```bash theme={null}
curl --request POST \
--url 'https://api.edges.run/v1/actions/linkedin-extract-people/run/live' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"identity_mode": "auto"
}'
```
This automatically distributes the load across all available accounts for optimal performance.
### Pricing
* **LinkedIn Accounts**: \$70/month per account
* **Sales Navigator Accounts**: \$125/month per account
These accounts are provisioned through third-party accredited services and fully managed by Edges. Direct access is not provided.
## Option 3: Managed Identities
Use Edges's managed account pool with no setup required.
### When to Use
* **Hassle-free automation** - No account management needed
* **Quick setup** - Start immediately without configuration
* **Cost-effective for small operations** - Pay per use
* **Testing and development** - No account setup required
### Setup
Simply use `identity_mode: "managed"` in your API calls:
```json theme={null}
{
"identity_mode": "managed",
"parameters": {}
}
```
### Benefits
* **No account setup** - Works immediately
* **Automatic load distribution** - Optimal performance
* **No restrictions** - Avoid rate limits and account issues
* **Simplified workflow** - Focus on business logic
### Limitations
* **Cost**: 1.5x standard credit cost
* **Not available for all actions** - Some require specific accounts
* **No personal account attribution** - Can't use your own accounts
## Choosing the Right Option
Use this decision guide to select the best approach for your use case:
### Decision Tree
**Yes** → Use **Option 1 (Sync Your Users')**
User-specific actions include:
* Sending messages, invitations, InMails
* Extracting users' own profile viewers
* Accessing users' personal connections
* Account-specific data extraction
**Yes** → Use **Option 2 (Rent Accounts)**
Dedicated bandwidth scenarios:
* Guaranteed capacity for large operations
* B2B services requiring consistent performance
* Professional data enrichment services
* Predictable costs for high-volume processing
**Yes** → Use **Option 3 (Managed Identities)**
Perfect for:
* Any volume (small to large scale)
* Quick testing and development
* Pay-per-use scenarios
* No account management overhead
### Quick Comparison by Use Case
| Use Case | Recommended Option | Why |
| -------------------------- | ------------------ | ------------------------------------------------ |
| **User Outreach** | Option 1 | Users need their personal accounts for messaging |
| **High-Volume Processing** | Option 3 | Great for any volume, hassle-free |
| **Dedicated Bandwidth** | Option 2 | Guaranteed capacity, consistent performance |
| **Data Enrichment** | Option 3 | Flexible volume, no account management |
| **Testing/Development** | Option 3 | Quick setup, works at any scale |
| **B2B Services** | Option 2 | Dedicated accounts for consistent service |
| **Small Automation** | Option 3 | Cost-effective, no setup fees |
### Cost Considerations
* **Option 1**: Standard credit cost + user setup overhead
* **Option 2**: \$70-125/month per account + standard credits
* **Option 3**: 1.5× standard credit cost, no setup fees
## Account Management & Support
### Invalid Account Handling
For managed accounts, Edges provides:
* **24-hour resolution** for invalid accounts
* **Automatic replacement** when needed
* **Proactive monitoring** to prevent issues
### Getting Help
* **Email**: [support@edges.run](mailto:support@edges.run)
* **Platform**: Contact us directly through the Edges app
* **Documentation**: See [Identity Modes](/v1/identities/modes) for technical details
# LinkedIn API Best Practices
Source: https://docs.edges.run/v1/linkedin/best-practices
The importance of using LinkedIn Profile IDs over mutable handles for reliable data access and integration.
## Understanding Profile Access and Optimizing Data Handling
When working with LinkedIn, the **“Profile is Not Accessible”** error often occurs when profile handles (the part of the LinkedIn URL after `/in/`) change. Since handles can be updated by users, workflows referencing outdated URLs may break.
To avoid this issue, it's essential to focus on **immutable and unique
identifiers**, like the **LinkedIn Profile ID**, rather than relying on
mutable handles.
By using Profile IDs, you can ensure stable, efficient, and reliable data access across your systems.
## Why Immutable Profile IDs Matter
* **Handles Can Change**: Users may update their LinkedIn handles, which can break automation workflows or CRM integrations.
* **Profile IDs Are Permanent**: Unlike handles, Profile IDs are immutable, offering a consistent way to reference profiles without disruption.
* **Versatile Use**: Profile IDs are essential for a variety of actions, such as creating outreach sequences or tracking user activities or updates
Traditional identifiers like emails, phone numbers, and handles can be problematic:
* **Not Immutable**: Emails and LinkedIn handles can change.
* **Not Always Unique**: Some domain names and company URLs overlap.
* **Region-Specific**: Phone numbers can be region-specific, limiting global reach.
By relying on Profile IDs and other immutable identifiers, you ensure:
* **Consistency**: Prevent errors caused by changing handles, emails, or phone numbers.
* **Scalability**: Profile IDs support global operations.
* **Advanced Insights**: Track job changes, new hires, and company growth without missing key data points.
## How to Effectively Use Profile Handles and IDs
1️⃣ **Retrieve the LinkedIn Profile Handle**
To find the LinkedIn profile handle, simply look at the URL, e.g. `https://www.linkedin.com/in/guillaume12345/` corresponds to the handle `guillaume12345`.
However, since handles are mutable and can change, **LinkedIn Profile IDs** offer a more stable solution to store IDs.
2️⃣ **Integrate Handles into Workflows**
Use handles in your workflows for actions like:
* Sending LinkedIn follow-ups using [Message LinkedIn Profile](/v1/api/actions/linkedin-message-profile)
* Filtering specific connections or job changes
* Tracking updates to companies or individuals
3️⃣ **Focus on Immutable Identifiers**
Relying solely on mutable identifiers, like emails or phone numbers, in your database, can lead to system errors.
For long-term reliability, stick with **Profile IDs**.
## Optimizing Operations with Unique Identifiers
To streamline your operations, use unique, immutable identifiers for both individuals and companies:
**For People**:
* **LinkedIn Profile ID** `linkedin_profile_id`: The most reliable way to track individuals.
* **Sales Navigator Profile ID** `sales_navigator_profile_id`: Useful for many workflows, though not unique, you can have up to 2 IDs.
**For Companies**:
* **LinkedIn Company ID** `linkedin_company_id`: An immutable identifier for companies on LinkedIn, e.g., Edges’s is `27193685`.
* **Sales Navigator Company ID** `sales_navigator_company_id`: Ideal for more advanced workflows.
**For Conversations**:
* **`linkedin_thread_id`**: Key for retrieving messages in a specific LinkedIn conversation, essential for communication tracking.
By focusing on these immutable identifiers, you can ensure smoother integrations and avoid common issues with changing handles.
## Recovering LinkedIn Profile URLs When Handles Change
When a LinkedIn profile handle changes, the old URL may continue working temporarily but will eventually return a 404 error. Here are two effective solutions to recover the new profile URL:
A "profile handle" is the final part of the URL, for example:
> [https://www.linkedin.com/in/amaury-riviere/](https://www.linkedin.com/in/amaury-riviere/) → here, the handle is `amaury-riviere`
When this handle is changed, the **old URL keeps working for a while**, but eventually it will **return a 404 error**.
### 💡 Solution 1 — Using the Sales Navigator Profile ID (Recommended)
If you've previously enriched profiles using **Edges**, you might have saved the **sales\_navigator\_profile\_id**.
Note: There can be two different IDs for the same user, so it's not strictly unique.
However, this ID is **very powerful**, as it allows you to **rebuild the LinkedIn profile URL**, even if the handle has changed.
### 💡 Solution 2 — Using the Extract People Profile
1. **Enrich your list** using the *Extract People Profile* action.
2. If you get a **404 error**, it means the handle is no longer valid.
3. **Keep track** of all profiles with inactive handles.
4. Then, use a **LinkedIn People Search** with this syntax:
```
"FULL NAME" AND "COMPANY NAME"
```
Example:
[https://www.linkedin.com/search/results/people/?keywords=%22John%20Doe%22%20AND%20%22Company%20Name%22](https://www.linkedin.com/search/results/people/?keywords=%22John%20Doe%22%20AND%20%22Company%20Name%22)
→ with the parameter `extract only unique profile`.
5. If you find the profile, you can **re-enrich it** to retrieve the **new handle**.
The **LinkedIn Profile ID** itself normally remains **the same**.
## Best Practices for Long-term Reliability
In summary, it's important to **keep both identifiers** — the **LinkedIn Profile ID** and the **Sales Navigator Profile ID** — for every profile you enrich.
* The **Sales Navigator ID** is especially useful because it allows you to **rebuild or regenerate a LinkedIn profile URL** later, even if the profile handle has changed.
* The **LinkedIn ID** serves as a **stable, unique identifier** that never changes, making it ideal for long-term storage and data consistency.
Keep in mind that in some cases, **a profile may have two different Sales Navigator IDs**, so always verify which one is currently active before using it.
By keeping both IDs, you ensure better reliability, traceability, and flexibility for any future LinkedIn data operations.
# Building Chrome Extensions for LinkedIn & Source Code
Source: https://docs.edges.run/v1/linkedin/chrome-extension
Best practices for building Chrome extensions tailored for LinkedIn and accessing source code examples.
Having built many Chrome Extensions in recent years and accumulating more than 20k users, as well as helping customers build their own,
we've developed a simple pattern to reduce your time to release and make sure your extension is approved.
This guide is a bit technical; you'll potentially need the help of a developer
for the following steps.
## Source Code
Complete source code is available on
[GitHub](https://github.com/edgesrun/chrome-extension-skeleton).
Following the README, you should have no difficulties building your own Chrome Extension.
Keep it simple and focus on moving most of the logic to an API. This reduces
debugging efforts and the need for frequent updates to the Chrome Extension
itself, which always requires a review from Google.
## Coding Tips
Overall proces:
* The extension retrieves cookies (`li_at`, `li_a`), stores them in **local storage**, and uses them for authentication.
* A process is already in place to update these cookies every hour using `chrome.alarms.onAlarm`.
Communication with the front-end:
* The front-end sends a message to the extension (e.g., `msg_fetch_cookies`).
* The extension responds by retrieving cookies and storing them in Chrome’s **local storage** first.
Always check the extension is installed before synchronizing cookies or
launching actions. For example send `msg_fetch_extensionId` from your front
and return from the extension the `extensionId` using `chrome.runtime.id`.
Refer to the [source
code](https://github.com/edgesrun/chrome-extension-skeleton/blob/main/settings/settings.js)
for examples.
Debugging the extension:
* You can check logs in **Google Chrome > Extensions > Manage Extension > Service Workers**.
* Use **console.log** to debug issues.
Remember to use proper storage & identification:
* Store cookies by **YOUR** **User ID (internal), Edges User ID, and Account ID** to **avoid mix-ups**.
* Use `chrome.storage.local.set()` to store data.
## Store Listing Tips
![]()
When preparing your Chrome Extension for submission to the Chrome Web Store, follow these tips to ensure approval:
* **Fill in the Store Listing Thoroughly**: Pay special attention to the “Privacy” section.
* **Minimize Permissions**: By following our coding tips and requesting only the minimal necessary permissions, you can avoid complications during Google's review process.
Google reviewers do read the code, so keep it clean and straightforward!
## Updating Your Extension
To update your Chrome Extension:
1. Change the version number inside the `manifest.json` file.
2. Zip the updated files.
3. Click on "Upload new package" in the Chrome Web Store dashboard under Menu > Package.
![]()
## Need Help?
Don't hesitate to reach out to our support team if you need assistance with building or submitting your Chrome Extension.
# LinkedIn Actions Data Changes
Source: https://docs.edges.run/v1/linkedin/deprecation
Understanding changes to available fields in LinkedIn actions, including deprecated fields and workarounds.
This page documents changes to available fields in LinkedIn actions when migrating to Edges. These changes are primarily due to LinkedIn's API updates and deprecations, not regressions in Edges.
**Why these changes?** LinkedIn updated its API endpoints, which required us to rebuild automations in Edges. As part of this update, certain fields that were previously available (often hidden fields not visible in LinkedIn's UI) have been removed or deprecated.
***
## Extract LinkedIn People Profile
### Missing Company Fields in Experiences
**Affected Fields:**
* `company_employees_range`
* `company_industry`
**Context:**
Previously, the action **Extract LinkedIn People Profile** returned fields like `company_employees_range` and `company_industry` inside experiences.
In Edges, these fields are no longer available.
**Why the change?**
* LinkedIn updated its **API endpoints**, which required us to **rebuild the People Profile automation** in Edges.
* As part of this update, certain fields — including `company_employees_range` and `company_industry` — were removed from the People endpoint.
* These data points were **never visible in the LinkedIn UI** (they were hidden fields), which is why LinkedIn decided to deprecate them.
**Current situation:**
* Previously, you may still occasionally see these fields.
* However, LinkedIn is **gradually deprecating the old endpoint**.
* This means results will become unreliable (returning `null`), and there is a risk of LinkedIn treating these endpoints as **honeypots** (risky to use).
**Workaround:**
If you need **company size or industry information**, you should use the **Company Profile Enrichment** action instead:
👉 [Extract LinkedIn Company](/v1/api/actions/linkedin-extract-company)
This action is the reliable way to retrieve those fields going forward.
***
This page will be updated as new deprecations and changes are identified. If you notice missing fields or unexpected changes, please contact support.
# LinkedIn Smart Limits
Source: https://docs.edges.run/v1/linkedin/limits
How Edges protects LinkedIn accounts with Smart Limits and best practices to prevent restrictions.
## Edges Smart Limits
Edges protects your clients' LinkedIn accounts with our unique **Smart Limits** system.
By using Edges exclusively, clients can run a high volume of actions without issues.
These limits help stay within LinkedIn's daily action caps, preventing account restrictions.
Smart Limits operate on a 24-hour sliding window.
**What happens when the limit is reached?** In real-time mode, requests will fail with a rate limit error. In async or schedule modes, tasks will be postponed and automatically resume once the limit is freed up.
**Example Over 24 hours**:
If it's Wednesday at 2 PM, Edges checks the past 24 hours for any activity:
* If the limit is hit (e.g., 1000/1000 actions), no new tasks are launched in async/schedule modes, or requests fail immediately in real-time mode.
* We periodically check to see if the limit is cleared, e.g., at 3 PM, there might be 100 actions freed up.
* The available actions may vary depending on when the limit was last checked.
Edges only tracks actions performed within the platform, not manual
actions on LinkedIn or using other automation tools.
### How Smart Limits Work
**Limits are per-action, per-identity.** Each LinkedIn action (e.g., `linkedin-connect-profile`, `salesnavigator-search-metrics`) has its own daily limit tracked separately for each identity.
| Concept | Explanation |
| -------------------------- | --------------------------------------------------------------------------------------------- |
| **Per-action** | Hitting the limit on `salesnavigator-search-metrics` doesn't affect `linkedin-extract-people` |
| **Per-identity** | Each identity has its own limit counter for each action |
| **24-hour sliding window** | Limits reset gradually, not all at once at midnight |
**Example:** If Identity A hits its `linkedin-connect-profile` limit, it can still run `linkedin-extract-people`. Identity B is unaffected.
### New identity ramp-up
Newly connected identities do not receive full quotas immediately. Capacity ramps up over **5 days** (one fifth of full capacity added per day) and, on **day 1 only**, over the **first 5 hours** (one fifth of the day-1 allowance added per hour).
**Example:** connection requests with a full quota of **25** / 24 h → **5** on day 1, **10** on day 2, **15** on day 3, **20** on day 4, **25** from day 5 onward. On day 1, the hourly cap within those first 5 hours is **1 → 2 → 3 → 4 → 5**.
See [LinkedIn Limits — New identity ramp-up](/v1/linkedin/limits#new-identity-ramp-up) for the full tables.
### Auto Mode and Rate Limits
When using `identity_mode=auto`, Edges distributes requests across all available identities. If **all identities** in your pool hit their Smart Limit for a specific action, you'll see:
```json theme={null}
{
"label": "LIMIT_REACHED",
"message": "Daily limit reached for linkedin.",
"error": "all integration identities are exhausted",
"postponed_until": "2025-12-23T15:15:42.523Z"
}
```
**What this means:**
* Every identity in your pool has reached its daily limit for this specific action
* The task is postponed until `postponed_until` (when limits start freeing up)
* Other actions may still work (limits are per-action)
**Solutions:**
* Add more identities to your pool
* Use `identity_mode=managed` to access Edges's account pool
* Wait for `postponed_until` — async tasks automatically retry
### Checking Your Current Limits
Use the [Get Identity Limits](/v1/api/identities/limits) endpoint to check real-time usage:
```bash theme={null}
GET /v1/identities/{identity_uid}/actions/{action_slug}/limits
```
**Example:** Check `salesnavigator-search-metrics` limits for a specific identity:
```bash theme={null}
curl -X GET "https://api.edges.run/v1/identities/your-identity-uid/actions/salesnavigator-search-metrics/limits" \
-H "X-API-Key: your-api-key"
```
This endpoint evaluates limits in real-time, which is resource-intensive. Use it sparingly — don't poll continuously. It is rate limited along with other identity management operations. Check the [Rate Limits documentation](/v1/runs/rate-limits#identity-management) for details.
## Key Points for Avoiding LinkedIn Restrictions
When implementing **Edges** for LinkedIn automation, it's crucial to inform your users about a few key actions to prevent account restrictions.
Key steps to follow:
| **Step** | **Action** |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| **1. Avoid Multiple Automation Tools** | Advise against using multiple automation tools simultaneously to prevent LinkedIn from flagging the account for suspicious activity. |
| **2. Match Timezone Settings** | Ensure the **timezone** selected in Edges matches the user's actual location or VPN country. |
### **Avoid Using Multiple Automation Tools Simultaneously**
Using **multiple automation tools** at once with Edges can cause issues.
* **Why?** Many automation tools don't manage IP addresses properly, which could trigger flags on LinkedIn. When using multiple tools, LinkedIn may detect activity from different sources, increasing the likelihood of restrictions.
* **The result:** LinkedIn might flag the account for suspicious activity, potentially resulting in restrictions.
### **Ensure Timezone Settings Match**
The `timezone` selected in Edges must match the country where you're logging into LinkedIn.
* **Why it matters:** The timezone field provisions a proxy IP matching that timezone/country. If the timezone in your Edges identity doesn't align with your LinkedIn login location, LinkedIn may restrict your account.
* **What to do:** Always check that the timezone in your Edges identity matches the country where you're logging into LinkedIn to avoid being flagged.
### **VPN Use: Match Locations Carefully**
Using a **VPN** can be helpful but needs careful management.
* **Best practice:** The country in your **VPN** should match the timezone set in Edges. If there's a mismatch, LinkedIn might flag your activity as suspicious.
* **Tip:** Double-check that the timezone in Edges matches your VPN's location, or disconnect the VPN when accessing LinkedIn to avoid issues.
### **What to Do if Your Client Gets a LinkedIn Restriction?**
* **Don't worry!** Restrictions are usually temporary. ⏳
* **Steps to follow**:
1. Are **other automation tools** running alongside Edges?
2. Does the **timezone setting** in Edges match the user's actual location?
3. If using a **VPN**, does the VPN location match Edges's timezone setting?
## Best Practices
* **Scale your efforts**: Use multiple identities and the **identity\_mode=auto** feature to manage higher action volumes while staying within LinkedIn's limits.
* **Avoid overloading**: Space out actions over time to improve efficiency and avoid triggering restrictions.
* **Monitor activity**: Regularly track identity usage to prevent exceeding limits unexpectedly.
* **Choose the right execution mode**: Use real-time mode for immediate results, async mode for large batches, and schedule mode for time-based automation.
By following these guidelines, you can ensure smooth LinkedIn automation without restrictions!
## LinkedIn Limits
### LinkedIn Commercial Limits
A single limit may be consumed by **multiple actions**. Use the [Get Identity Limits](/v1/api/identities/limits) endpoint to see all limits that apply to a specific action.
## Identity Ramp-Up
When a LinkedIn identity is **newly connected**, its effective capacity ramps up gradually instead of starting at the full quotas in the limits table.
Ramp-up applies to **all limits** tied to that identity (connection requests, visits, messages, searches, etc.). The **full capacity** is the value shown in the quotas table for that identity’s account level.
### 5-day ramp-up
Full capacity is split into **5 equal steps**. Each day after the identity is connected, **one additional fifth** is unlocked:
| Day after connection | Share of full capacity | Example: connection requests (full = 25 / 24 h) |
| -------------------- | ---------------------- | ----------------------------------------------- |
| Day 1 | 1/5 (20%) | **5** |
| Day 2 | 2/5 (40%) | **10** |
| Day 3 | 3/5 (60%) | **15** |
| Day 4 | 4/5 (80%) | **20** |
| Day 5+ | 5/5 (100%) | **25** |
At the end of **day 5**, the identity reaches **full capacity** for all limits.
## Identity rate limits (all actions combined)
These caps apply to the **identity as a whole**, not per action. All actions executed by the same identity **share** these windows — they are global throughput limits on total activity.
| Window | Default cap (identity-wide) |
| -------------- | --------------------------- |
| Per second | 5 |
| Per minute | 50 |
| Per 15 minutes | 500 |
| Per 4 hours | 2,500 |
| Per 24 hours | 15,000 |
## Action rate limits
Each limit defines how many times a specific type of action can be executed within a defined time window.
## Limit ↔ Actions & Quotas
Some limits vary depending on the **account level**: `default`, `CLASSIC`, or `SALES_NAV`.
Most quotas use a **24-hour** sliding window, meaning they reset every 24 hours. InMail uses **\~31 days** .
| **Limit Name** | **Value LinkedIn/Sales Navigator** | **Per-minute cap** |
| ------------------------------------- | -------------------------------------------------------------------- | --------------------------- |
| Max **profile visits** | default & CLASSIC: 80 / 24 h · SALES\_NAV: 500 / 24 h | 10 |
| Max **messages sent** | default, CLASSIC & SALES\_NAV: 250 / 24 h | 10 |
| Max **connection requests** | default: 25 / 24 h · CLASSIC & SALES\_NAV: 30 / 24 h | 10 (default & CLASSIC only) |
| Max **profile enrichments** | CLASSIC: 700 / SALES\_NAV: 700 / 24 h | 5 |
| Max **company enrichments** | CLASSIC: 2000 / SALES\_NAV: 2000 / 24 h | 20 |
| Max **job enrichments** | CLASSIC: 5000 / SALES\_NAV: 5000 / 24 h | 10 |
| Max **profile components** | 450 / 24 h (experiences, educations, skills) | 9 |
| Max **contact info** | default, CLASSIC & SALES\_NAV: 250 / 24 h | — |
| Max **event invitations sent** | 100 / 24 h | 20 |
| Max **linkedin search people** | default & SALES\_NAV: 450 / 24 h | 10 |
| Max **salesnavigator search people** | default & SALES\_NAV: 950 / 24 h | 20 |
| Max **linkedin search company** | default & SALES\_NAV: 450 / 24 h | 10 |
| Max **salesnavigator search company** | default & SALES\_NAV: 950 / 24 h | 20 |
| Max **search saved people** | default & SALES\_NAV: 5,000 / 24 h | 20 |
| Max **search saved company** | default & SALES\_NAV: 5,000 / 24 h | 20 |
| Max **InMail sent** | default: 5 / \~31 d · CLASSIC: 15 / \~31 d · SALES\_NAV: 50 / \~31 d | 10 |
| Max **get post** | 10,000 / 24 h | 40 |
| Max **get post commenters** | 10,000 / 24 h | 40 |
| Max **get post likers** | 10,000 / 24 h | 40 |
| Max **get post reposters** | 10,000 / 24 h | 40 |
| Max **get people post activity** | 10,000 / 24 h | 30 |
| Max **get people comment activity** | 10,000 / 24 h | 30 |
| Max **get people reaction activity** | 10,000 / 24 h | 30 |
| Max **Extract profile handle and id** | 10,000 / 24 h | 30 |
| Max **get people reaction activity** | 10,000 / 24 h | 30 |
## Important Operational Notes
* **New identities** ramp up to full capacity over **5 days** and, on day 1, over the **first 5 hours** (see [New identity ramp-up](#new-identity-ramp-up)).
* Limits are **rolling windows**, not calendar-based.
* Per-minute caps apply **even if the daily quota is not exhausted**.
* Some actions consume **multiple limits simultaneously** (e.g., visit + enrichment).
* Sales Navigator accounts have significantly higher visit/search quotas.
* InMail limit works on a **\~31-day window**, not daily.
* **Default identity rate limits** (above) are shared across all actions on the same identity. **Per-action quotas** in the limits table below (`limit_value` per limit type) apply separately in addition to those global caps.
### Limit Reached Errors
While Edges protects your clients' LinkedIn accounts with Smart Limits, you may still see 429 errors originating from different sources. Here's how to identify and handle them.
| Error Type | `status_code` | `error_label` | Source | Handling Recommendation |
| ------------------ | ------------- | --------------- | --------- | -------------------------------------------------- |
| Edges Rate Limit | `429` | N/A | Edges API | Wait for `Retry-After`, apply exponential backoff |
| LinkedIn (Guarded) | `429` | `LIMIT_REACHED` | LinkedIn | Wait at least 24h, retry once usage drops |
| LinkedIn (Raw) | `429` | `STATUS_429` | LinkedIn | Apply exponential backoff, monitor identity health |
For `LIMIT_REACHED` retry implementation see [Handling Rate Limit Errors](/v1/error-reference#handling-rate-limit-errors-429).
**Best Practices**:
* Always implement **retry with exponential backoff** (e.g. 30s → 60s → 120s…)
* Use **identity rotation** or `identity_mode=auto` to spread traffic or rely on `identity_mode=managed` to let Edges handle it (higher credits consumption)
* Use **async or schedule modes** for large workloads to avoid real-time limits (limits are managed on our side)
For more details on handling errors, refer to our [Error Reference](/v1/error-reference).
# Quickstart
Source: https://docs.edges.run/v1/quickstart
Get your first LinkedIn search results in under 2 minutes.
## What is Edges?
Edges is the API for LinkedIn automation and data enrichment. One API call to:
Profiles, posts, companies
Add LinkedIn data to your SaaS or agent
Messages, invites, follows
Find leads at scale
**No LinkedIn account setup required** — start with `identity_mode: "managed"` and upgrade later.
Add Edges Documentation to your AI assistant or IDE thanks to our Model Context Protocol server. Best advices directly from the documentation into your IDE !
***
## Try it now
Get your API key from [Developer Settings](https://app.edges.run/settings/developers), then run:
```bash cURL theme={null}
curl --request POST \
--url https://api.edges.run/v1/actions/linkedin-search-people/run/live \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: YOUR_API_KEY' \
--data '{
"identity_mode": "managed",
"input": {
"linkedin_people_search_url": "https://www.linkedin.com/search/results/people/?keywords=software%20engineer"
}
}'
```
```typescript TypeScript SDK theme={null}
import { Edges } from '@edgesrun/sdk';
const ed = new Edges({ apiKey: process.env.EDGES_API_KEY! });
const { data } = await ed.linkedin.searchPeople({
identity_mode: "managed",
input: {
linkedin_people_search_url: "https://www.linkedin.com/search/results/people/?keywords=software%20engineer"
}
});
console.log(data);
```
**Success!** If you see an array of LinkedIn profiles, you're ready to build.
### What you'll get back
```json theme={null}
[
{
"full_name": "John Doe",
"linkedin_profile_url": "https://www.linkedin.com/in/johndoe",
"job_title": "Senior Software Engineer",
"company_name": "Tech Company",
"headline": "Software Engineer | Full Stack Developer",
"location": "San Francisco Bay Area",
"connection_degree": "2nd"
}
]
```
**Managed mode cost:** Using `identity_mode: "managed"` costs 1.5× standard credits but requires zero setup. Perfect for getting started.
**Built-in protection:** Edges applies **Smart Limits** to protect LinkedIn accounts from restrictions automatically. [Learn more](/v1/linkedin/limits).
***
## How it works
Browse [60+ Actions](/v1/api/actions) for LinkedIn, Sales Navigator, and data enrichment.
Use `managed` (no setup), your users' accounts (`direct`), or rotate your accounts (`auto`).
Send a POST request with your input. Results return in real-time.
Each successful result consumes credits — [see how billing works](https://support.edges.run/en/articles/12398360-understanding-how-credits-are-billed).
***
## Identity modes explained
Most Actions require a LinkedIn account to execute. Edges gives you three options:
| Mode | Setup | Cost | Best for |
| --------- | ---------------------------- | ---------------------- | ------------------------------------------------ |
| `managed` | None | 1.5× credits | Getting started, testing, hassle-free automation |
| `direct` | Connect your users' accounts | Standard | User-specific outreach, personal accounts |
| `auto` | Rent accounts from Edges | \$70-125/mo + standard | High-volume, dedicated bandwidth |
For production use or user-specific actions (sending messages, invitations):
1. [Create an Identity](/v1/api/identities/create) to represent your user
2. [Connect their LinkedIn](/v1/api/integrations/connect) via Chrome Extension or API
3. Use `identity_ids: ["identity_uid"]` instead of `identity_mode: "managed"`
**Full guide:** [LinkedIn Identity Options](/v1/identities/sync-vs-managed)
***
## Handling errors
The API uses consistent error responses across all endpoints:
```json theme={null}
{
"error_label": "INVALID_INPUT",
"error_scope": "input",
"error_ref": "ERR-12345",
"message": "The provided input is invalid.",
"status_code": 400
}
```
| Status | Meaning |
| ------ | ----------------------------------------------------- |
| `200` | Success |
| `400` | Bad request — check your input |
| `401` | Invalid or missing API key |
| `424` | LinkedIn-specific error (check `error_label`) |
| `500` | Server error — [contact us](mailto:support@edges.run) |
Use `error_label` and `error_scope` for programmatic error handling. See the full [Error Reference](/v1/error-reference).
***
## What's next?
Browse 60+ LinkedIn, Sales Navigator, and enrichment actions
Type-safe SDK with autocomplete for faster development
Process thousands of records with callbacks
Deep dive into Identities, Integrations, and Runs
***
## Need help?
* **Email:** [support@edges.run](mailto:support@edges.run)
* **Full API Reference:** [/v1/api/introduction](/v1/api/introduction)
* **Troubleshooting:** [FAQ & Common Issues](/v1/faq-troubleshooting)
* **Ask your AI tools** about Edges Documentation thanks to our MCP : [Edges MCP](/mcp)
# Managing Callbacks
Source: https://docs.edges.run/v1/runs/callbacks
Learn how to list, retrieve, and replay callbacks using the Edges API.
## What are Callbacks?
Callbacks are the way Edges delivers results for `async` and `schedule` execution modes.
Instead of waiting for the entire operation to complete, you receive results progressively as they become available.
**When to use callbacks:** Choose `async` or `schedule` mode when you need to process large datasets, want to consume data in parallel, or need to handle long-running operations without timeouts.
Callbacks are only useful if you can **trust that all of them are received and processed**.\
To ensure you never miss any data, see [Why Managing Callback History Matters](#why-managing-callback-history-matters).
Understanding callback statuses is essential for handling callbacks correctly. Here are quick definitions:
* **`PENDING`**: The callback is queued and waiting to be delivered to your webhook endpoint.
* **`RUNNING`**: The callback has been sent to your endpoint and is being processed (or was successfully delivered).
* **`FAILED`**: The callback delivery failed (e.g., network error, timeout, or your endpoint returned an error status code).
* **`SUCCESS`**: The callback was successfully delivered to your endpoint and your endpoint returned a successful HTTP status code (2xx).
These are **callback statuses** that indicate the delivery status of the callback itself. They are different from **run statuses** (like `BLOCKED`, `FAILED`, `SUCCEEDED`) which indicate the execution state of the run. See [Understanding Run Statuses vs Callback Statuses](#understanding-run-statuses-vs-callback-statuses) below for more details.
## Quick Start
### 1. Set up your webhook endpoint
Create an HTTPS endpoint that can receive POST requests with JSON payloads.
### 2. Configure your action call
Include a `callback` parameter with your webhook URL:
```json theme={null}
{
"inputs": [...],
"callback": {
"url": "https://yourdomain.com/webhook",
"headers": {
"Authorization": "Bearer your_token"
},
"on": "all"
}
}
```
Set `"on": "final"` instead of `"all"` if you only want to receive a single callback when the job completes. With `"final"` mode, the callback indicates the run status, and you then fetch results using [`GET /runs/{run_uid}/outputs`](/v1/api/runs/outputs). This is ideal for automation tools like n8n, Make, or Zapier. See [Streaming vs Final Callbacks](#streaming-vs-final-callbacks) for details.
### 3. Handle incoming callbacks
* **For `on: "all"` mode:** Process the JSON payloads as they arrive. Each callback contains results and metadata. Verify completeness by comparing the run output count with received results.
* **For `on: "final"` mode:** Receive a single callback with run status, then fetch all results using [`GET /runs/{run_uid}/outputs`](/v1/api/runs/outputs).
For detailed setup and management, see the sections below.
## Understanding Async and Schedule Modes
`async` and `schedule` execution modes are both async modes: the results are not sent immediately in the response payload but delivered during execution via callbacks.
`schedule` is built on top of `async` and only adds ways to postpone and schedule calls. Both modes share the same callback delivery mechanism. For a detailed comparison and guidance on when to use each mode, see [When to use live, async or schedule modes.](/v1/runs/overview).
### Setting Up Callbacks
Every action call in async/schedule mode requires a `callback` parameter:
Your webhook URL that will receive the callback data. Must be HTTPS.
Optional headers for authentication or custom metadata (API keys, etc.).
Defines when you want to receive callbacks. See [Streaming vs Final Callbacks](#streaming-vs-final-callbacks) below.
* `"all"` (default): Stream callbacks progressively as results are processed
* `"final"`: Receive a single callback when all inputs are processed or an error occurs
Please refer to each async/schedule action in the [API Reference](/v1/api/introduction) for specific details.
## Streaming vs Final Callbacks
By default, Edges sends callbacks progressively as results become available (`callback.on: "all"`). However, you can opt to receive only a single callback when the entire job completes by setting `callback.on: "final"`.
### When to Use Each Mode
| Mode | `callback.on` | Behavior | Best For |
| ------------- | ----------------- | ------------------------------------------- | ---------------------------------------------------------------------------- |
| **Streaming** | `"all"` (default) | Multiple callbacks as results are processed | Real-time processing, large datasets, progressive data consumption |
| **Final** | `"final"` | Single callback when job completes | Automation tools (n8n, Make, Zapier), simple integrations, cost optimization |
### Streaming Mode (`"all"`)
This is the default behavior. You receive callbacks progressively:
* One callback per batch/page of results with `run.status: RUNNING`
* One final callback with `run.status: SUCCEEDED` when complete
```json theme={null}
{
"inputs": [...],
"callback": {
"url": "https://yourdomain.com/webhook",
"on": "all"
}
}
```
**Advantages:**
* Start processing data immediately as it arrives
* Better for large datasets (stream instead of waiting)
* Real-time progress tracking
**Considerations:**
* Your endpoint receives multiple requests per run
* Requires handling multiple callbacks and aggregating results
* Must verify completeness by comparing output count with received results
**Verifying Completeness (All Callbacks Mode):**
After receiving the final callback with `run.status: SUCCEEDED`, verify that all callbacks were received:
```javascript theme={null}
// 1. Get the run details to retrieve output_count
const runResponse = await fetch(`https://api.edges.run/v1/runs/${run_uid}`, {
headers: { 'X-API-Key': 'your_api_key' }
});
const run = await runResponse.json();
const expectedOutputCount = run.output_count;
// 2. Count all results received in callbacks
// (You should track this as callbacks arrive)
const receivedResultsCount = /* sum of all results.length from callbacks */;
// 3. Compare counts
if (receivedResultsCount === expectedOutputCount) {
console.log('✅ All callbacks received - data is complete');
} else {
console.warn(`⚠️ Missing callbacks: Expected ${expectedOutputCount}, received ${receivedResultsCount}`);
// Fetch missing results or replay callbacks
const outputs = await fetch(`https://api.edges.run/v1/runs/${run_uid}/outputs`, {
headers: { 'X-API-Key': 'your_api_key' }
});
// Process missing results
}
```
### Final Mode (`"final"`)
You receive a single callback only when the job is complete:
* One callback with `run.status: SUCCEEDED` or `run.status: PARTIAL_SUCCEEDED` indicating the run status
* Or one callback with `run.status: FAILED` if an error occurred
* **Important:** The callback indicates the run status but does not contain all results. You must fetch results using the [`GET /runs/{run_uid}/outputs`](/v1/api/runs/outputs) API endpoint.
```json theme={null}
{
"inputs": [...],
"callback": {
"url": "https://yourdomain.com/webhook",
"on": "final"
}
}
```
**How it works:**
1. Receive final callback with run status (`SUCCEEDED`, `PARTIAL_SUCCEEDED`, or `FAILED`)
2. Fetch all results using `GET /runs/{run_uid}/outputs` API endpoint
3. Process the complete result set
**Advantages:**
* Dramatically reduces webhook executions (1 instead of N)
* Simpler integration logic (no aggregation needed)
* Lower costs for webhook-based automation platforms
* Data completeness guaranteed by the GET Results API
**Considerations:**
* Must wait for the entire job to complete before receiving status
* Requires an additional API call to fetch results after the callback
**Fetching Results (Final Callback Mode):**
After receiving the final callback, fetch all results:
```javascript theme={null}
// 1. Receive final callback with run.status
// Example callback payload:
// { "run": { "run_uid": "...", "status": "SUCCEEDED" }, ... }
// 2. Fetch all results using the GET API
const outputsResponse = await fetch(
`https://api.edges.run/v1/runs/${run_uid}/outputs?limit=100&offset=0`,
{ headers: { 'X-API-Key': 'your_api_key' } }
);
const outputs = await outputsResponse.json();
// 3. Process the complete result set
// Note: Use pagination (limit/offset) if there are many results
```
**For automation tools like n8n, Make, or Zapier:** Use `callback.on: "final"` to avoid flooding your workflows with multiple webhook triggers. This can significantly reduce your automation platform costs, especially for jobs with many results.
## Data Completeness Guarantees
Each callback mode ensures data completeness differently. Understanding these guarantees helps you build robust integrations that never miss data.
### All Callbacks Mode (`on: "all"`)
Results are delivered **progressively** through multiple callbacks during the run execution.
**How completeness is ensured:**
1. Each callback contains a subset of the run results
2. When the run finishes, verify completeness by:
* Retrieving the **run output count** using [`GET /runs/{run_uid}`](/v1/api/runs/get) - the `output_count` field indicates the total number of outputs generated
* Comparing it with the **number of results received via callbacks** (count all results from callbacks with `run.status: RUNNING` and the final `run.status: SUCCEEDED`)
**Outcome:**
* ✅ **Counts match** → All callbacks were received, data is complete
* ⚠️ **Counts differ** → One or more callbacks are missing
* Use the [List Callbacks endpoint](/v1/api/callbacks/list) to identify missing callbacks
* Retry missing callbacks using the [Replay Callback endpoint](/v1/api/callbacks/replay)
* Or fetch missing results directly via [`GET /runs/{run_uid}/outputs`](/v1/api/runs/outputs)
* To recover input-level errors (e.g., 404s) that aren't in outputs, use [`GET /runs/{run_uid}/inputs`](/v1/api/runs/inputs)
**Guarantee:**
👉 Data completeness is validated by a **final comparison between received callbacks and the run output count**.
### Final Callback + GET Results Mode (`on: "final"`)
Results are delivered **after the run is fully completed** using a two-step process.
**How it works:**
1. A single **final callback** indicates the run status (`SUCCEEDED`, `PARTIAL_SUCCEEDED`, or `FAILED`)
2. The client then retrieves all results using the [`GET /runs/{run_uid}/outputs`](/v1/api/runs/outputs) API call
**Outcome:**
* Results are fetched directly from the server via the API
* No intermediate callbacks are involved
* No callback verification needed
**Guarantee:**
👉 Data completeness is ensured by the **GET Results API**, not by callbacks.
### Summary
| Mode | Result Delivery | Completeness Check |
| ---------------------------------------- | ----------------------------------- | -------------------------------------- |
| **All Callbacks** (`on: "all"`) | Multiple callbacks during execution | Final comparison with run output count |
| **Final Callback + GET** (`on: "final"`) | One final callback + API retrieval | No callback verification needed |
### Which Mode Should I Use?
* **All Callbacks** → If you need real-time processing or progressive results
* **Final Callback + GET** → If you prefer a simpler flow and can wait for completion
## Callback Structure
All callbacks follow the same consistent format:
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
```json async callback format theme={null}
{
"callback_ref_uid": "string",
"run": {
"run_uid": "string",
"batch_uid": "string",
"status": "CREATED" || "INVALID" || "QUEUED" || "SCHEDULED" || "BLOCKED" || "STOPPED" || "RUNNING" || "FAILED" || "PARTIAL_SUCCEEDED" || "SUCCEEDED",
"scheduled_run_uid": "string | null"
},
"input": {} || null,
"custom_data": {} || null,
"error": {} || null,
"results": [] || null
}
```
To track or tag your inputs, you can attach any custom metadata to each input via the `custom_data` field. It is especially useful
in `async` and `schedule` modes to help you get context on the results.
This applies even when running with multiple inputs: each input will produce one or more callbacks, **each carrying its own `custom_data`**.
This object is then **injected as-is** at the root of every callback, allowing you to correlate each result with your own data or internal references.
### Callback Payload Fields
Stable callback identifier that remains the same across retries. Use this for **safe deduplication** — even if your endpoint receives multiple retries, this identifier always refers to the same logical callback event.
Execution context containing `run_uid` (unique to the entire run), `batch_uid` (unique to this batch), `status` (current execution state), and optionally `scheduled_run_uid` (present when the run was triggered by a schedule — use it to correlate callbacks with [scheduled runs](/v1/api/schedules/get)).
The processed input data that was used for this batch (cleaned and validated by our engine).
Your custom data passed via `inputs.custom_data`. Available at the root level for easy access.
Error details if this batch failed. Follows the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
The actual results for this batch (null if there was an error). Format matches the specific action's output.
### Callback HTTP Headers
Webhook requests include the following HTTP headers for identification and tracking:
| Header | Description |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------- |
| **X-Callback-Ref** | Stable callback identifier, identical across retries (same as `callback_ref_uid` in the payload). Use for **deduplication**. |
| **X-Run-Callback** | Unique identifier for each delivery attempt. Changes on every retry. Use for **delivery tracking**. |
Use `X-Callback-Ref` (or `callback_ref_uid` in the payload) to detect and safely ignore duplicate callbacks. Use `X-Run-Callback` to log and debug individual delivery attempts.
## Understanding Run Statuses vs Callback Statuses
It's important to distinguish between two different types of statuses in the callback system:
### Run Statuses
Run statuses (found in `run.status` within the callback payload) indicate the execution state of the entire run or batch. The available run statuses are:
* **`CREATED`**: The run or schedule has been created but not yet queued for execution.
* **`INVALID`**: The run or schedule is invalid (e.g., due to bad input or configuration).
* **`QUEUED`**: The run is waiting in the queue to be executed.
* **`SCHEDULED`**: The run is scheduled to execute at a future time (applies to scheduled/CRON jobs).
* **`BLOCKED`**: The run is blocked because the input is invalid (bad input). For example, certain URLs like `https://www.linkedin.com/products/...` do not correspond to a valid LinkedIn company page. The callback itself is processed correctly, but the input cannot be processed.
* **`STOPPED`**: The run was stopped before completion (manually or by the system).
* **`RUNNING`**: The run is currently in progress.
* **`FAILED`**: The run has failed. This can occur when the input seems correct, but during processing in the callback, it returns a failed status with an error (e.g., `424 – No results`). In this case, the callback itself was processed correctly, even if the page doesn't exist or returns nothing.
* **`PARTIAL_SUCCEEDED`**: The run completed with some errors, but partial results are available.
* **`SUCCEEDED`**: The run completed successfully.
### Callback Statuses
Callback statuses (used when filtering callbacks via the API) indicate the delivery status of the callback to your webhook endpoint:
* **`PENDING`**: The callback is queued and waiting to be delivered.
* **`RUNNING`**: The callback has been sent to your endpoint.
* **`FAILED`**: The callback delivery failed (network error, timeout, or your endpoint returned an error).
* **`SUCCESS`**: The callback was successfully delivered and your endpoint returned a successful response.
### Understanding BLOCKED and FAILED Run Statuses
When processing async operations, you may encounter inputs that cannot be processed. Here's how to interpret the different scenarios:
#### BLOCKED Status
A run status of `BLOCKED` indicates that the input is invalid (bad input). This happens when:
* The input format is incorrect or doesn't match the expected type
* The input references a resource that doesn't exist or isn't accessible
* Example: URLs like `https://www.linkedin.com/products/...` that don't correspond to a LinkedIn company page
In this case, the callback is processed correctly by Edges, but the input itself cannot be processed because it's invalid.
#### FAILED Status (424 – No results)
A run status of `FAILED` with a `424 – No results` error indicates that:
* The input format appears correct
* During processing, no results could be found for the provided input
* The input may redirect to a 404 page on LinkedIn or the target resource doesn't exist
* **Important**: The callback itself was processed correctly by Edges, even though no results were found
Technically, when a callback returns `FAILED` with `424 – No results`, the callback processing itself succeeded — Edges correctly processed your request and determined that no results exist. The failure is in the data retrieval, not in the callback delivery mechanism.
## Using `custom_data` to Track Inputs
One of the most powerful features of callbacks is the ability to attach custom metadata to each input using the `custom_data` object.
This data is sent back in every callback, allowing you to correlate results with your internal systems.
When calling an action in `async` or `schedule` mode, include a `custom_data` field for each input.
```json theme={null}
{
"inputs": [
{
"linkedin_profile_url": "https://www.linkedin.com/in/elisa-morgera-88b76b95/",
"custom_data": {
"internal_id": "12345",
"type": "lead"
}
},
{
"linkedin_profile_url": "https://www.linkedin.com/in/astrid-puentes-ria%C3%B1o-83658a14/",
"custom_data": {
"internal_id": "671",
"type": "lead"
}
}
],
"callback": {
"url": "https://yourdomain.com/webhook",
"headers": {
"Authorization": "Bearer your_token"
}
}
}
```
Each callback will include the same `custom_data` at the root level.\
Example for the first input:
```json theme={null}
{
"callback_ref_uid": "550e8400-e29b-41d4-a716-446655440000",
"run": { "run_uid": "...", "batch_uid": "...", "status": "RUNNING" },
"input": {
"linkedin_profile_url": "https://www.linkedin.com/in/elisa-morgera-88b76b95/"
},
"custom_data": {
"internal_id": "12345",
"type": "lead"
},
"results": [ { "linkedin_profile_id": "...", "full_name": "Elisa Morgera" } ]
}
```
And for the second input:
```json theme={null}
{
"callback_ref_uid": "550e8400-e29b-41d4-a716-446655440001",
"run": { "run_uid": "...", "batch_uid": "...", "status": "RUNNING" },
"input": {
"linkedin_profile_url": "https://www.linkedin.com/in/astrid-puentes-ria%C3%B1o-83658a14/"
},
"custom_data": {
"internal_id": "671",
"type": "lead"
},
"results": [ { "linkedin_profile_id": "...", "full_name": "Astrid Puentes Riaño" } ]
}
```
You can now correlate each callback to internal data using the `custom_data` fields.\
This makes it easy to process results in your own system — even with multiple inputs and parallel callbacks.
## How Callbacks Work
Understanding how callbacks are processed and delivered helps you build robust integrations.
### Parallel Processing & Pagination
Async actions are designed to scale efficiently by processing multiple pages concurrently:
* **Improved performance**: Pages are processed in parallel
* **Manageable payloads**: Each page generates a separate callback
* **Faster time-to-first-result**: Start consuming data immediately
### Callback Flow
The callback flow depends on the `callback.on` setting:
Action is triggered in async mode with `max_results: 100`
Backend automatically paginates results with `page_size: 10`
You receive 10 callbacks with:
* `run.status: RUNNING` (this is the run status, indicating the run is in progress)
* Each containing \~10 results (may vary slightly as we filter out ads and other content)
Once the run completes, you receive one final callback with `run.status: SUCCEEDED` (indicating the run finished successfully)
**Important:** You may receive multiple callbacks for a single execution, and they may arrive out of order due to parallel processing. Always use the `run_uid` and `batch_uid` to track and organize your data.
Action is triggered in async mode with `max_results: 100`
Backend processes all results. No callbacks are sent during execution.
Once all inputs are processed, you receive **one single callback** with:
* `run.status: SUCCEEDED` or `PARTIAL_SUCCEEDED` (indicating the run completed)
* Or `run.status: FAILED` if an error occurred
* **Note:** The callback indicates status but does not contain all results
After receiving the final callback, fetch all results using:
* [`GET /runs/{run_uid}/outputs`](/v1/api/runs/outputs) to retrieve the complete result set
* Results are fetched directly from the server, ensuring data completeness
**Two-step process:** With final mode, you receive exactly one callback per run (status only), then fetch results via the API. This makes it ideal for automation workflows that trigger on webhook events and prefer fetching data on-demand.
## Handling Callbacks & Idempotency
Even with a single callback (final mode), you should implement idempotency to handle potential retries. For streaming mode, this is even more critical since you receive multiple callbacks.
### Best Practices
* **Use `callback_ref_uid` for deduplication**: This stable identifier is the same across retries, making it the recommended way to detect and ignore duplicate callbacks
* **Track processed results** using meaningful keys (e.g., `linkedin_profile_id`) or `run_uid`/`batch_uid`
**For streaming mode (`on: "all"`):**
* **Aggregate progressively** as you receive callbacks with `run.status: RUNNING` (these contain partial results)
* **Finalize only** when you receive a callback with `run.status: SUCCEEDED` (this indicates the run completed)
* **Verify completeness** by comparing the run `output_count` (from `GET /runs/{run_uid}`) with the total number of results received in callbacks
* If counts don't match, identify and replay missing callbacks or fetch results via the API
**For final mode (`on: "final"`):**
* You receive a single callback indicating the run status (`SUCCEEDED`, `PARTIAL_SUCCEEDED`, or `FAILED`)
* **Fetch all results** using [`GET /runs/{run_uid}/outputs`](/v1/api/runs/outputs) after receiving the callback
* No aggregation needed - the API returns the complete result set
### Benefits
This approach allows you to:
* Stream results progressively (streaming mode) or receive status then fetch results (final mode)
* Handle partial failures gracefully
* Ensure data consistency even with retries
* Verify data completeness using run output count (streaming mode) or API retrieval (final mode)
## Managing Callbacks
Edges provides endpoints to track, retrieve, and manage your callbacks.
### Why Managing Callback History Matters
Even with a reliable setup, **callbacks may not always reach your endpoint**. This is often invisible without using the callback history endpoints — missing callbacks mean missing data.
If you rely solely on your callback URL logs, you might never detect missed callbacks, as they were never delivered to your system.
#### Common Reasons for Missed Callbacks
* **Network interruptions** between Edges and your callback URL
* **Temporary downtime** of your server or API endpoint
* **Gateway or firewall restrictions** blocking Edges IPs
* **TLS/SSL handshake issues** (expired certificates, protocol mismatch)
* **Slow responses** from your server causing timeouts
* **Transient cloud provider issues** on either side
#### How to Detect & Resolve Issues
You can use the [List Callbacks endpoint](/v1/api/callbacks/list) to programmatically detect missing or failed callbacks:
1. **Schedule a periodic check** (e.g., once per day) to call `GET /runs/callbacks` filtered by `status=FAILED`.
For example:
```sh theme={null}
curl --request GET \
--url 'https://api.edges.run/v1/runs/callbacks?limit=20&sort=-created_at&status=FAILED' \
--header 'X-API-Key: '
```
The number of callbacks can be adjusted with the `limit` parameter up to 20.
You can use the `offset` param if needed to paginate through results and retrieve all failed callbacks until a date.
If you track the `run_uid`, you can also filter by `run_uid` to check for specific runs and verify the callbacks were successfully received run by run.
2. **Analyze the `http_status` field** to identify the root cause (e.g., connection refused, timeout).\
If the callback reached your endpoint but ended with an error, inspect your own server logs to diagnose the issue.
`http_status` is the HTTP status code returned by your endpoint. It is meaningful to identify what's happening on your callback URL.
Refer to the [HTTP Status Codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) documentation for more details.
While it will be enough to identify most issues, you may need to check your own server logs for more details in some cases:
* **4xx errors**: Client-side issues (e.g., authentication, bad request)
* **5xx errors**: Server-side issues (e.g., internal server error,...)
Note that you may also have "silent" failures if you have logic issues in your callback processing code that do not return an error status code but still fail to process the data correctly. So best practice is to implement explicit error handling on your endpoint and always log the received callbacks and their processing results.
3. **Fix the issue(s)** (e.g., adjust firewall, fix SSL, improve server response time).
While you can automatically replay failed callbacks, it's crucial to understand why they failed first.
This prevents flooding your endpoint with retries without fixing the underlying issue, ensures you stay within the replay limits, and guarantees you don't miss any data.
Use the replay functionality carefully — you can only replay the same callback **up to 3 times**.
4. **Replay the affected callbacks** with [`POST /runs/callbacks/{callback_uid}/replay`](/v1/api/callbacks/replay).
#### Daily Monitoring Example
**Recommended Daily Check:**
Run a cron job that:
* Fetches all failed callbacks from the past 24 hours
* Logs the details for investigation
* Automatically retries transient failures using the replay endpoint
Regularly checking the callback history helps ensure **no data is silently lost** and allows you to maintain a robust, fault-tolerant integration.
#### Additional Use Cases for Callback History
* **Post-incident recovery:** After downtime, retrieve missed callbacks and replay them to backfill data. You can also use [`GET /runs/{run_uid}/inputs`](/v1/api/runs/inputs) to recover all input-level data including errors that aren't available in the outputs endpoint.
* **Audit & compliance:** Keep a complete log of all callbacks sent and their statuses for troubleshooting or audits.
* **Performance monitoring:** Track the proportion of successful vs failed callbacks over time to improve infrastructure reliability.
## Examples
### Listing Callbacks
Use [`GET /runs/callbacks`](/v1/api/callbacks/list) to retrieve all callbacks with filtering and pagination.
* **`status`**: Filter by callback delivery status. Valid values are:
* `PENDING`: Callbacks queued and waiting to be delivered
* `RUNNING`: Callbacks that have been sent to your endpoint
* `FAILED`: Callbacks that failed to be delivered (network errors, timeouts, or endpoint errors)
* `SUCCESS`: Callbacks that were successfully delivered and acknowledged by your endpoint
* **`run_uid`**: Filter by specific run to see all callbacks for that run
* **`limit` & `offset`**: Pagination controls to retrieve callbacks in batches
* **`sort`**: Sorting order (prefix with `-` for descending, e.g., `-created_at` to get newest first)
```bash theme={null}
curl -X GET "https://api.edges.run/v1/runs/callbacks?status=FAILED&limit=20&sort=-created_at" \
-H "Accept: application/json" \
-H "X-API-Key: "
```
### Getting a Specific Callback
Use [`GET /runs/callbacks/{callback_uid}`](/v1/api/callbacks/get) to fetch detailed information:
```bash theme={null}
curl -X GET "https://api.edges.run/v1/runs/callbacks/{callback_uid}" \
-H "Accept: application/json" \
-H "X-API-Key: "
```
### Replaying Callbacks
Use [`POST /runs/callbacks/{callback_uid}/replay`](/v1/api/callbacks/replay) to retry failed callbacks:
**How replay works:**
* Each replay creates a new callback (up to 3 total replays)
* You can only replay the original callback, not callback responses
* This helps you track each attempt and identify specific issues with your webhook URL
**When to use replay:**
* Your webhook URL was temporarily unavailable
* You received a callback but want to retry processing
* You need to debug callback delivery issues
```bash theme={null}
curl -X POST "https://api.edges.run/v1/runs/callbacks/{callback_uid}/replay" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json"
```
If you have a sandbox, you will have access to several workspaces. The API key will define the current workspace for the calls.
## Next Steps
See the [API Reference](/v1/api/callbacks) for detailed endpoint usage, parameters, and more examples.
# Live Mode: Safe Practices
Source: https://docs.edges.run/v1/runs/live-mode-safe-practices
Use Edges live mode without overloading LinkedIn: cold-account ramp-up, spacing, sequencing, jitter, and recommended delays per action.
**Live mode** talks to LinkedIn **directly and synchronously** for each call. Unlike **async** or **schedule**, Edges does **not** apply the same built-in pacing, batching, or orchestration on your behalf. At scale, careless live usage can look like automation and trigger throttling, checkpoints, or account risk.
**Goal:** mimic **human-like** usage—similar in spirit to what Edges does in async—by spacing work, avoiding parallelism, and adding randomness.
Using live mode unsafely puts your account at serious risk—you may be temporarily rate limited or even banned from LinkedIn. Having your account blocked due to unsafe usage is not a possibility, it's only a matter of time.
Treat live mode as **your responsibility** to rate-limit and sequence. If you need guardrails by default, prefer [**async**](/v1/runs/overview#async-mode) or [**schedule**](/v1/runs/overview#schedule-mode).
***
## Rules of thumb 👍
* **Spread actions over time** — never fire everything at once.
* **Invitations** — respect a **daily cap** and space each attempt by **tens of seconds to minutes**, with **randomized** gaps.
* **Profile visits** — distribute across the day; delay between each live call.
* **Search / pagination** — always wait between **each page** (each follow-up request using `X-Pagination-Next` or the next cursor).
* **No parallel live calls** for the same identity on risky outreach—keep the pipeline **sequential** (one in flight, then the next).
* **Random + jitter** — add variability to every delay so intervals are not perfectly periodic.
***
## Cold Account
A **cold account** is one with little recent LinkedIn activity: new identity, long idle period, or a profile that rarely browses, searches, or messages. LinkedIn’s systems weigh **sudden spikes** more heavily than steady habits—going from near-zero to high-volume live API traffic in a day is one of the riskiest patterns.
**Ramp up over several days** instead of jumping to your target throughput immediately:
1. **Days 1–2** — Keep volume **very low** (a handful of benign actions if you must: light reads, spaced visits, minimal outreach). Use **generous** gaps between calls—often **longer** than the [suggested minimum spacing](#suggested-minimum-spacing-live) table—and **no parallelism** for the same identity.
2. **Days 3–5** — Gradually increase **daily call count** and **breadth** (more pages, more profiles), still with **jitter** and **sequential** execution. If you see `429`, checkpoints, or unusual friction, **slow down** and extend the ramp.
3. **After \~a week of stable, human-like patterns** — You can approach your intended steady-state spacing and volume, still respecting daily caps, invitation limits, and the **Rules of thumb** guidance above.
There is no single “correct” curve: align ramp length with how **warm** the account already is and how aggressive your actions are (visits vs. InMail vs. connect). When in doubt, **stretch the ramp** and favor **async** or **schedule** until the account has a believable baseline of activity.
***
## Suggested minimum spacing (live)
These are **starting points** for time **between successive live calls** of the same type for the same identity. Adjust per account and monitoring; when in doubt, **\~60 s** is a reasonable default.
| Action | Recommended gap between calls |
| -------------------------------------------------------------------------------- | ----------------------------------------------------- |
| [`linkedin-inmail-profile`](/v1/api/actions/linkedin-inmail-profile) | **\~30 s** |
| [`linkedin-message-profile`](/v1/api/actions/linkedin-message-profile) | **\~60 s** |
| [`linkedin-visit-profile`](/v1/api/actions/linkedin-visit-profile) | **\~30 s** |
| [`linkedin-connect-profile`](/v1/api/actions/linkedin-connect-profile) | **\~60 s** (avoid bursts; small batches spaced apart) |
| [`salesnavigator-inmail-profile`](/v1/api/actions/salesnavigator-inmail-profile) | **\~30 s** |
| **General (other live actions)** | **\~60 s** |
Combine these delays with **jitter** (see example below), not fixed sleep only.
***
## Simple Safe pattern: sleep + jitter (JavaScript)
After each live `POST` completes, wait **base delay + random jitter** before the next call:
```javascript theme={null}
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
/** baseMs = minimum gap; adds 0..jitterMaxMs random extra */
async function waitBetweenLiveCalls(baseMs, jitterMaxMs = 15_000) {
const jitter = Math.floor(Math.random() * (jitterMaxMs + 1));
await sleep(baseMs + jitter);
}
// Example: linkedin-visit-profile — ~30s base, up to +15s jitter
await fetch("https://api.edges.run/v1/actions/linkedin-visit-profile/run/live", {
method: "POST",
headers: {
"X-API-Key": process.env.EDGES_API_KEY,
"Content-Type": "application/json",
},
body: JSON.stringify({ /* inputs, identity_mode, … */ }),
});
await waitBetweenLiveCalls(30_000);
// next live call…
```
For **pagination**, call `waitBetweenLiveCalls` with a minimum timeframe **after every page** (after each response before following `X-Pagination-Next`).
***
### LinkedIn Commercial Limits
Keep in mind that LinkedIn has multiple mechanisms in place to detect and flag activity that doesn't appear human. These safeguards are why we enforce daily limits on async and scheduled runs—to ensure security and reduce the risk of triggering LinkedIn's automated protections.
A single limit may be consumed by **multiple actions**. Use the [Get Identity Limits](/v1/api/identities/limits) endpoint to see all limits that apply to a specific action.
## Identity Ramp-Up
When a LinkedIn identity is **newly connected**, its effective capacity ramps up gradually instead of starting at the full quotas in the limits table.
Ramp-up applies to **all limits** tied to that identity (connection requests, visits, messages, searches, etc.). The **full capacity** is the value shown in the quotas table for that identity’s account level.
### 5-day ramp-up
Full capacity is split into **5 equal steps**. Each day after the identity is connected, **one additional fifth** is unlocked:
| Day after connection | Share of full capacity | Example: connection requests (full = 25 / 24 h) |
| -------------------- | ---------------------- | ----------------------------------------------- |
| Day 1 | 1/5 (20%) | **5** |
| Day 2 | 2/5 (40%) | **10** |
| Day 3 | 3/5 (60%) | **15** |
| Day 4 | 4/5 (80%) | **20** |
| Day 5+ | 5/5 (100%) | **25** |
At the end of **day 5**, the identity reaches **full capacity** for all limits.
## Identity rate limits (all actions combined)
These caps apply to the **identity as a whole**, not per action. All actions executed by the same identity **share** these windows — they are global throughput limits on total activity.
| Window | Default cap (identity-wide) |
| -------------- | --------------------------- |
| Per second | 5 |
| Per minute | 50 |
| Per 15 minutes | 500 |
| Per 4 hours | 2,500 |
| Per 24 hours | 15,000 |
## Action rate limits
Each limit defines how many times a specific type of action can be executed within a defined time window.
## Limit ↔ Actions & Quotas
Some limits vary depending on the **account level**: `default`, `CLASSIC`, or `SALES_NAV`.
Most quotas use a **24-hour** sliding window, meaning they reset every 24 hours. InMail uses **\~31 days** .
| **Limit Name** | **Value LinkedIn/Sales Navigator** | **Per-minute cap** |
| ------------------------------------- | -------------------------------------------------------------------- | --------------------------- |
| Max **profile visits** | default & CLASSIC: 80 / 24 h · SALES\_NAV: 500 / 24 h | 10 |
| Max **messages sent** | default, CLASSIC & SALES\_NAV: 250 / 24 h | 10 |
| Max **connection requests** | default: 25 / 24 h · CLASSIC & SALES\_NAV: 30 / 24 h | 10 (default & CLASSIC only) |
| Max **profile enrichments** | CLASSIC: 700 / SALES\_NAV: 700 / 24 h | 5 |
| Max **company enrichments** | CLASSIC: 2000 / SALES\_NAV: 2000 / 24 h | 20 |
| Max **job enrichments** | CLASSIC: 5000 / SALES\_NAV: 5000 / 24 h | 10 |
| Max **profile components** | 450 / 24 h (experiences, educations, skills) | 9 |
| Max **contact info** | default, CLASSIC & SALES\_NAV: 250 / 24 h | — |
| Max **event invitations sent** | 100 / 24 h | 20 |
| Max **linkedin search people** | default & SALES\_NAV: 450 / 24 h | 10 |
| Max **salesnavigator search people** | default & SALES\_NAV: 950 / 24 h | 20 |
| Max **linkedin search company** | default & SALES\_NAV: 450 / 24 h | 10 |
| Max **salesnavigator search company** | default & SALES\_NAV: 950 / 24 h | 20 |
| Max **search saved people** | default & SALES\_NAV: 5,000 / 24 h | 20 |
| Max **search saved company** | default & SALES\_NAV: 5,000 / 24 h | 20 |
| Max **InMail sent** | default: 5 / \~31 d · CLASSIC: 15 / \~31 d · SALES\_NAV: 50 / \~31 d | 10 |
| Max **get post** | 10,000 / 24 h | 40 |
| Max **get post commenters** | 10,000 / 24 h | 40 |
| Max **get post likers** | 10,000 / 24 h | 40 |
| Max **get post reposters** | 10,000 / 24 h | 40 |
| Max **get people post activity** | 10,000 / 24 h | 30 |
| Max **get people comment activity** | 10,000 / 24 h | 30 |
| Max **get people reaction activity** | 10,000 / 24 h | 30 |
| Max **Extract profile handle and id** | 10,000 / 24 h | 30 |
| Max **get people reaction activity** | 10,000 / 24 h | 30 |
## Important Operational Notes
* **New identities** ramp up to full capacity over **5 days** and, on day 1, over the **first 5 hours** (see [New identity ramp-up](#new-identity-ramp-up)).
* Limits are **rolling windows**, not calendar-based.
* Per-minute caps apply **even if the daily quota is not exhausted**.
* Some actions consume **multiple limits simultaneously** (e.g., visit + enrichment).
* Sales Navigator accounts have significantly higher visit/search quotas.
* InMail limit works on a **\~31-day window**, not daily.
* **Default identity rate limits** (above) are shared across all actions on the same identity. **Per-action quotas** in the limits table below (`limit_value` per limit type) apply separately in addition to those global caps.
***
## Related
* [Execution modes overview](/v1/runs/overview) — when to prefer live vs async vs schedule
* [Pagination](/v1/runs/pagination) — live mode and `X-Pagination-Next`
* [Rate limits](/v1/runs/rate-limits)
* [LinkedIn limits](/v1/linkedin/limits)
# Managing Runs
Source: https://docs.edges.run/v1/runs/manage
Learn how to launch, monitor, filter, and manage your runs using the Edges API.
This guide explains how to launch, monitor, filter, sort, and retrieve results from your runs using the Edges API.
## Launching a Run
* Use the API to start a new run by calling the appropriate action endpoint (e.g., `/v1/actions/{action-name}/async`) with your desired parameters.
* Choose between execution modes: `live` (synchronous), `async` (asynchronous), or `schedule` (scheduled/CRON).
Implementation differences:
* In `live` mode, use the `input` field to send a single input at a time (one by one).
* In `async` and `schedule` modes, use the `inputs` field to send up to 100,000 inputs in a single request.
## Monitoring and Managing Runs
For now, there is no dashboard to view runs—you must use the API for all management tasks.
### Listing Runs
* Use [`GET /v1/runs`](/v1/api/runs/list) to retrieve a list of runs.
* You can filter runs by:
* `status` (e.g., `SUCCEEDED`, `FAILED`, etc.)
* `action_name` (filter by specific action)
* `execution_mode` (`LIVE` or `ASYNC`)
* `uid`, `user_uid` (workspace member that triggered the Run), `workspace_uid` (filter by unique identifiers)
* Pagination is supported via `limit` (default: 10, max: 100) and `offset` (default: 0) for listing runs. For run outputs and inputs, use cursor-based pagination via the `X-Pagination-Next` header (see [Pagination Guide](/v1/runs/pagination#paginating-run-outputs--inputs)).
* Sorting is available using the `sort` parameter. Prefix a field with `-` for descending order (e.g., `-created_at`). You can sort by fields like `created_at`, `status`, or `updated_at`.
#### Example: List all async runs that succeeded
```bash theme={null}
curl -X GET "https://api.edges.run/v1/runs?execution_mode=ASYNC&status=SUCCEEDED" \
-H "Accept: application/json" \
-H "X-API-Key: "
```
#### Example: List the 20 most recent runs (sorted by creation date, descending)
```bash theme={null}
curl -X GET "https://api.edges.run/v1/runs?limit=20&sort=-created_at" \
-H "Accept: application/json" \
-H "X-API-Key: "
```
### Getting a Specific Run
* Use [`GET /v1/runs/{run_uid}`](/v1/api/runs/get) with the run UID to fetch detailed information about a specific run, including its status, execution mode, timestamps, and any errors.
```bash theme={null}
curl -X GET "https://api.edges.run/v1/runs/{run_uid}" \
-H "Accept: application/json" \
-H "X-API-Key: "
```
### Resuming a Run
* If a run is paused or stopped, you can resume it using [`POST /v1/runs/{run_uid}/resume`](/v1/api/runs/manage).
* Provide the run UID and specify the action (e.g., `resume`).
```bash theme={null}
curl -X POST "https://api.edges.run/v1/runs/{run_uid}/resume" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json" \
-d '{
// any required parameters
}'
```
### Continuing an Incremental Run
If a run was launched with `sync_mode: "incremental"` using an [Engagement Identity](/v1/identities/engagement), you can continue it to fetch only the new data since the last retrieval using [`POST /v1/runs/{run_uid}/continue`](/v1/api/runs/continue).
A run can only be continued if its status is one of: `BLOCKED`, `STOPPED`, `FAILED`, `PARTIAL_SUCCEEDED`, or `SUCCEEDED`.
When a run is continued, its status and all related inputs are reset to `SCHEDULED`.
```bash theme={null}
curl -X POST "https://api.edges.run/v1/runs/{run_uid}/continue" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json"
```
For more information about incremental sync, see the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode).
## Status Lifecycle
Async and scheduled runs progress through a series of statuses, see below for details:
* **`CREATED`**: The run or schedule has been created but not yet queued for execution.
* **`INVALID`**: The run or schedule is invalid (e.g., due to bad input or configuration).
* **`QUEUED`**: The run is waiting in the queue to be executed.
* **`SCHEDULED`**: The run is scheduled to execute at a future time (applies to scheduled/CRON jobs).
* **`BLOCKED`**: The run is blocked because the input is invalid (bad input). For example, certain URLs like `https://www.linkedin.com/products/...` do not correspond to a valid LinkedIn company page. The callback itself is processed correctly, but the input cannot be processed.
* **`STOPPED`**: The run was stopped before completion (manually or by the system).
* **`RUNNING`**: The run is currently in progress.
* **`FAILED`**: The run has failed. This can occur when the input seems correct, but during processing in the callback, it returns a failed status with an error (e.g., `424 – No results`). In this case, the callback itself was processed correctly, even if the page doesn't exist or returns nothing.
* **`PARTIAL_SUCCEEDED`**: The run completed with some errors, but partial results are available.
* **`SUCCEEDED`**: The run completed successfully.
Monitoring these statuses helps you track the state of your jobs.
* For async runs, monitor status via the API or receive updates via your webhook.
* For scheduled runs, use the schedules list endpoint to track and manage jobs.
## Data Retention
Edges automatically manages data retention to maintain optimal platform performance. Understanding retention periods helps you plan your data storage and retrieval strategies.
### Run Data Retention
* **Runs and Flow Runs**: Automatically archived after **90 days**
* Once archived, runs are no longer accessible via the API
* Run outputs and statistics are also cleaned up after 90 days
* This ensures faster queries and better overall system performance
* **Usage Records**: Automatically cleaned up after **5 days**
* Integration account usage data is retained for 5 days
* This data is used for rate limiting and quota management
If you need to keep run data longer than 90 days, make sure to:
* Store run results in your own system via callbacks
* Export important run data before the retention period expires
* Use the callback system to receive and persist results as they're generated
Outputs are **not available** for runs executed in `live` mode. It only works for runs executed in `async` or `schedule` mode. For live mode runs, results are returned directly in the API response.
### Best Practices
* **Use Callbacks**: For long-term data storage, rely on callbacks to receive and store results in your own database
* **Export Important Data**: Periodically export run metadata and results if you need historical records
* **Monitor Recent Activity**: Focus on runs from the last 90 days when querying via the API
Data retention is automated and runs daily. This helps maintain platform performance and ensures faster API responses for recent data.
See the [API Reference](/v1/api/runs/list) for detailed endpoint usage and more examples.
# Overview of Execution Modes
Source: https://docs.edges.run/v1/runs/overview
When to use live, async or schedule modes.
Edges supports multiple ways to execute actions and workflows, including synchronous runs, asynchronous runs, and scheduled executions. This section explains the different execution modes and how to choose the right one for your use case.
* **Synchronous Runs:** Immediate execution, results returned in real-time.
* **Asynchronous Runs:** Execution happens in the background, results can be fetched later.
* **Scheduled Runs:** Actions are scheduled to run at a specific time or on a recurring basis.
Here is a quick overview of each mode to help you decide which one fits your needs:
| Execution Mode | Data Delivery | When to Use |
| -------------- | --------------------------------- | -------------------------------------------------- |
| **Live** | Immediate (synchronous) | Real-time workflows, single inputs, few results |
| **Async** | Background (via callback stream) | Batch jobs, large datasets, automated pagination |
| **Schedule** | Recurring (via cron) or postponed | Scheduled runs, regular syncs, postponed execution |
For detailed pagination handling, see the [Pagination Guide](/v1/runs/pagination). To learn more about managing runs and schedules, see the following sections.
## Execution Statuses
When running actions in async or schedule mode, the following statuses may be encountered:
* **`CREATED`**: The run or schedule has been created but not yet queued for execution.
* **`INVALID`**: The run or schedule is invalid (e.g., due to bad input or configuration).
* **`QUEUED`**: The run is waiting in the queue to be executed.
* **`SCHEDULED`**: The run is scheduled to execute at a future time (applies to scheduled/CRON jobs).
* **`BLOCKED`**: The run is blocked because the input is invalid (bad input). For example, certain URLs like `https://www.linkedin.com/products/...` do not correspond to a valid LinkedIn company page. The callback itself is processed correctly, but the input cannot be processed.
* **`STOPPED`**: The run was stopped before completion (manually or by the system).
* **`RUNNING`**: The run is currently in progress.
* **`FAILED`**: The run has failed. This can occur when the input seems correct, but during processing in the callback, it returns a failed status with an error (e.g., `424 – No results`). In this case, the callback itself was processed correctly, even if the page doesn't exist or returns nothing.
* **`PARTIAL_SUCCEEDED`**: The run completed with some errors, but partial results are available.
* **`SUCCEEDED`**: The run completed successfully.
## Live Mode
You receive data immediately as it is processed, making this the easiest mode to implement for quick integrations.
**Key characteristics:**
* **Synchronous execution** - results returned in the API response
* **Manual pagination** - you handle pagination using cursor and response headers
* **Real-time processing** - fastest time to first result
* **Rate limit handling** - you implement retry logic for `429 Too Many Requests` responses
* **Your pacing at scale** - live calls hit LinkedIn directly without async/schedule orchestration; follow [Live mode: safe practices](/v1/runs/live-mode-safe-practices) for spacing, sequencing, and jitter
Live mode is ideal for real-time workflows where you need immediate results and can handle pagination manually.
See the [Pagination Guide](/v1/runs/pagination) for detailed pagination handling.
## Async Mode
When you run an action asynchronously, the execution happens in the background and results are delivered via callbacks.
**Key characteristics:**
* **Background execution** - non-blocking, your application continues running
* **Automatic pagination** - Edges handles pagination internally
* **Progressive delivery** - results streamed via callbacks as they become available
* **Callback-based** - results delivered to your webhook URL
* **Batch processing** - ideal for large datasets and long-running tasks
* **Automatic retries** - transient errors are retried (see below)
Async and schedule runs automatically retry on transient errors. Each run may be attempted up to **11 times** in total (initial attempt + 10 retries).
Async mode is ideal for long-running tasks, batch processing, or when you want to avoid blocking your application while waiting for results.
Results are delivered progressively via multiple callbacks, allowing you to start processing data as soon as it becomes available.
**Prefer polling over callbacks?** You can retrieve outputs directly via [`GET /runs/{run_uid}/outputs`](/v1/api/runs/outputs) without setting up a webhook endpoint. See [Rate Limits](/v1/runs/rate-limits#run-outputs) for polling limits.
You can attach any metadata to each input using the `custom_data` object. This data is sent in every callback, allowing you to
correlate results with your backend.
* Each callback relates to **a single input**, so `custom_data` is included at the **root level** of the callback payload
* Avoid sending large or nested structures: most use cases are covered with a single internal ID
* Keep the payload **reasonably small** to avoid hitting webhook size limits
### Callbacks Structure
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
```json async callback format theme={null}
{
"callback_ref_uid": "string",
"run": {
"run_uid": "string",
"batch_uid": "string",
"status": "CREATED" || "INVALID" || "QUEUED" || "SCHEDULED" || "BLOCKED" || "STOPPED" || "RUNNING" || "FAILED" || "PARTIAL_SUCCEEDED" || "SUCCEEDED",
"scheduled_run_uid": "string | null"
},
"input": {} || null,
"custom_data": {} || null,
"error": {} || null,
"results": [] || null
}
```
To track or tag your inputs, you can attach any custom metadata to each input via the `custom_data` field. It is especially useful
in `async` and `schedule` modes to help you get context on the results.
This applies even when running with multiple inputs: each input will produce one or more callbacks, **each carrying its own `custom_data`**.
This object is then **injected as-is** at the root of every callback, allowing you to correlate each result with your own data or internal references.
To learn more about callbacks, please take a look at [Managing Callbacks](/v1/runs/callbacks).
### Available Endpoints for Runs
You can manage and monitor your runs using the following endpoints:
| Action | Method | Endpoint | Description |
| --------------- | ------ | ------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- |
| List all runs | `GET` | [`/v1/runs`](/v1/api/runs/list) | Retrieve a list of all runs, with filtering and pagination options. |
| Get a run | `GET` | [`/v1/runs/{run_uid}`](/v1/api/runs/get) | Fetch detailed information and status for a specific run using its unique identifier. |
| Get run status | `GET` | [`/v1/runs/{run_uid}/status`](/v1/api/runs/status) | Lightweight status check for a run without fetching full details. |
| Get run inputs | `GET` | [`/v1/runs/{run_uid}/inputs`](/v1/api/runs/inputs) | Retrieve all inputs for a run with their status and errors. Includes failed inputs that aren't available in outputs. |
| Get run outputs | `GET` | [`/v1/runs/{run_uid}/outputs`](/v1/api/runs/outputs) | Poll for run outputs without using callbacks. Supports cursor-based pagination via `X-Pagination-Next`. |
| Resume a run | `POST` | [`/v1/runs/{run_uid}/resume`](/v1/api/runs/manage) | Resume a paused or stopped run. |
| Continue a run | `POST` | [`/v1/runs/{run_uid}/continue`](/v1/api/runs/continue) | Continue an `incremental` sync run to fetch new data since the last retrieval. |
| Cancel a run | `POST` | [`/v1/runs/{run_uid}/cancel`](/v1/api/runs/cancel) | Stop an async/schedule run. Already processed results remain available. |
Refer to the [API Reference](/v1/api/runs/list) for request/response details and usage examples for each endpoint.
## Schedule Mode
When you run an action in `schedule` mode, a CRON-job is created that executes at defined intervals.
**Key characteristics:**
* **Scheduled execution** - runs at defined times (daily, weekly, custom CRON expressions)
* **Postponed execution** - can delay execution to a specific time
* **Automatic pagination** - same as Async mode
* **Callback-based** - results delivered via callbacks like Async mode
* **Recurring tasks** - ideal for regular data syncs and automated workflows
* **Automatic retries** - same retry behavior as [async mode](#async-mode)
Schedule mode is ideal for recurring tasks, regular data syncs, or when you want to automate actions at specific intervals
without implementing your own scheduling system.
Results are delivered progressively exactly like in Async mode, via callbacks on the URL set in the `callback.url` parameter.
### Understanding CRON Expressions
A CRON expression is a string used to define the schedule for recurring jobs. It consists of five fields separated by spaces, representing:
1. Minute (0-59)
2. Hour (0-23)
3. Day of month (1-31)
4. Month (1-12)
5. Day of week (0-6, where 0 = Sunday)
**Examples:**
* `0 9 * * 1-5` — Every weekday (Monday to Friday) at 9:00 AM
* `30 2 * * *` — Every day at 2:30 AM
* `0 0 1 * *` — On the first day of every month at midnight
* `*/30 * * * *` — Every 30 minutes
You can use online tools like [crontab.guru](https://crontab.guru/) to build and test your CRON expressions.
### Available Endpoints for Schedules
You can manage and monitor your schedules using the following endpoints:
| Action | Method | Endpoint | Description |
| ------------------ | ------ | ------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------- |
| List all schedules | `GET` | [`/v1/schedules`](/v1/api/schedules/list) | Retrieve a list of all schedules, with filtering and pagination options. |
| Get a schedule | `GET` | [`/v1/schedules/{scheduled_run_uid}`](/v1/api/schedules/get) | Fetch detailed information and status for a specific schedule using its unique identifier. |
| Manage a schedule | `POST` | [`/v1/schedules/{scheduled_run_uid}/{action}`](/v1/api/schedules/manage) | Update, pause, resume, or delete a schedule. Provide the schedule UID and the desired action. |
Refer to the [API Reference](/v1/api/schedules/list) for request/response details and usage examples for each endpoint.
## Incremental Sync Mode
Both **Async** and **Schedule** modes support an optional **incremental sync** mechanism. Instead of retrieving the full dataset on every run, you can set `sync_mode: "incremental"` inside the `parameters` object to fetch **only new data** since the last retrieval.
Incremental sync is only available on [engagement-free actions](/v1/identities/engagement#included-actions) and requires an **Engagement Identity** (`type: "engagement"`). Standard identities cannot use this feature.
### How It Works
1. **First run (initial full sync):** When `sync_mode` is set to `incremental` and no previous data has been retrieved, the system performs a full sync limited by `max_results` (either the value you set or the action's default).
2. **Subsequent runs (incremental):** Once a first retrieval has been completed, the next runs automatically switch to incremental mode and return only newly available data.
With each continue or scheduled iteration, the system fetches up to `max_results` new items.
If more new items were created than the `max_results` limit between two iterations, items beyond that limit will be **lost** and cannot be recovered.
This happens because data is always fetched **from the most recent to the oldest**.
To minimize this risk, choose a `max_results` value and schedule frequency that match your expected data volume.
### Using Incremental Sync with Async Mode
In async mode, you trigger incremental updates manually by **continuing** a completed run:
```bash theme={null}
curl -X POST "https://api.edges.run/v1/runs/{run_uid}/continue" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json"
```
Each call to [`POST /v1/runs/{run_uid}/continue`](/v1/api/runs/continue) resets the run and fetches up to `max_results` new items.
### Example: Async Incremental Sync
```bash theme={null}
# 1. Launch an async run with incremental sync
curl -X POST "https://api.edges.run/v1/actions/linkedin-extract-connections/run/async" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json" \
-d '{
"inputs": [{ "linkedin_url": "https://linkedin.com/in/johndoe" }],
"callback": { "url": "https://yourdomain.com/callback" },
"parameters": {
"sync_mode": "incremental"
}
}'
# Returned body
{
"run_id":xxxxxxxx,
"run_uid":"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx", (use this one)
...
"action_name":"linkedin-extract-connections",
"status":"SCHEDULED"
}
# 2. Once the run completes, continue it later to get new data
curl -X POST "https://api.edges.run/v1/runs/{run_uid}/continue" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json"
```
### Using Incremental Sync with Schedule Mode
In schedule mode, incremental sync is automatic: each scheduled iteration fetches only the new data since the last execution. No manual continue call is needed.
In scheduled mode, if the previous run is still in progress when the next iteration is triggered, that iteration will be **skipped**. The following iteration will trigger the update instead.
### Example: Scheduled Incremental Sync
```bash theme={null}
# Schedule a recurring incremental sync every day at 9am
curl -X POST "https://api.edges.run/v1/actions/linkedin-extract-messages/run/schedule" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json" \
-d '{
"inputs": [{ "conversation_id": "..." }],
"callback": { "url": "https://yourdomain.com/callback" },
"cron": "0 9 * * *",
"timezone": "Europe/Paris",
"parameters": {
"sync_mode": "incremental"
}
}'
```
### Supported Actions
The following actions currently support incremental sync:
| Action | Description |
| -------------------------------------------------------------------------------------- | ------------------------------- |
| [`linkedin-extract-connections`](/v1/api/actions/linkedin-extract-connections) | Extract LinkedIn connections |
| [`linkedin-extract-messages`](/v1/api/actions/linkedin-extract-messages) | Extract LinkedIn messages |
| [`linkedin-extract-profile-viewers`](/v1/api/actions/linkedin-extract-profile-viewers) | Extract profile viewers |
| [`linkedin-extract-page-followers`](/v1/api/actions/linkedin-extract-page-followers) | Extract LinkedIn page followers |
### Continuable Run Statuses
A run can only be continued if its status is one of:
* `BLOCKED`
* `STOPPED`
* `FAILED`
* `PARTIAL_SUCCEEDED`
* `SUCCEEDED`
When continued, the run status and all related inputs are reset to `SCHEDULED`.
### Limitations
With each continue or scheduled iteration, the system fetches up to `max_results` new items.
If more new items were created than the `max_results` limit between two iterations, items beyond that limit will be **lost** and cannot be recovered.
This happens because data is always fetched **from the most recent to the oldest**.
To minimize this risk, choose a `max_results` value and schedule frequency that match your expected data volume.
## Quick Decision Guide
* **Live** ⚡️ - Need results immediately and can handle pagination manually
* **Async** 📦 - Running batch jobs with automated pagination and callback delivery
* **Schedule** 🕒 - Need recurring or postponed execution with the same benefits as Async
# Handle Pagination
Source: https://docs.edges.run/v1/runs/pagination
Learn how pagination works in live, async, and schedule execution modes.
Some actions return multiple pages of results, especially search actions and extractions that return lists of data. How pagination works depends on your execution mode.
## Quick Decision Guide
Not sure which approach fits your use case? Here's how to decide:
* ⚡️ **Live mode** is ideal when you have **a single input and expect few results**. It's the simplest and fastest way to get your data immediately.
* 📦 **Async/Schedule modes** are better suited when you expect **a lot of results** and want to **avoid manual pagination**. Results are streamed progressively via callbacks, as soon as they're processed.
**Result count may vary:** LinkedIn and other platforms may insert sponsored content or dynamic results that don't match your exact
request. We filter these out, which may result in fewer results than expected.
## Execution Modes & Pagination
Edges handles pagination differently based on your execution mode:
| Execution Mode | Who Handles Pagination | How You Control It |
| ------------------ | ---------------------- | ---------------------------------------------- |
| `live` | You (manually) | Use `cursor` param and follow response headers |
| `async`/`schedule` | Edges | Use `max_results` parameter only |
* **`live` mode**: You handle pagination manually using the cursor from response headers.
* **`async`/`schedule` modes**: Pagination is automatic — you just specify how many results you want.
## Async Pagination (Automatic)
In `async` and `schedule` modes, pagination is completely automated:
* **No manual handling required** - Edges handles all pagination internally
* **Use `max_results` parameter** - Specify how many total results you want
* **Results delivered via callbacks** - Each page generates a separate callback
* **Progressive delivery** - Start receiving data immediately
`max_results` has a default value for each action (see [API Reference](/v1/api/introduction)).
There's also a maximum limit you cannot exceed (`0 <= x <= max_value`).
### How Async Pagination Works
1. You specify `max_results: 100` in your request
2. Edges automatically paginates with optimal `page_size`
3. You receive multiple callbacks, each with a batch of results
4. Each callback has `status: RUNNING` until the final `SUCCEEDED` callback
For detailed callback handling, see [Managing Callbacks](/v1/runs/callbacks).
## Live Pagination (Manual)
In `live` mode, you control pagination manually for real-time responses:
In `live` mode, you won't receive the **total number of pages** in advance.\
In any case, you should keep following the `X-Pagination-Next` header **until it's no longer present** — this means you've reached the end.
As you have full ownership over fetching the results, `live` mode does not support `max_results` parameter.
### Pagination Parameters
Maximum number of items per page (read-only, varies by action)
Cursor value obtained from the `X-Pagination-Next` response header of a previous request. Cursors expire after 24 hours.
### Pagination Headers
Each response includes headers to help you navigate:
URL for the next page containing the `cursor` parameter — **follow this exactly**
Not always present — some actions **do not support previous page navigation**
### Cursor-Based Pagination
Live mode uses cursor-based pagination for reliable, consistent results:
* The `X-Pagination-Next` header contains a URL with a `cursor` parameter
* This `cursor` is **required** to access the next page
* Cursors expire after **24 hours** — if expired, restart pagination from the beginning
* You **cannot jump to a specific page** — always follow the cursor sequence
Do **not try to construct cursor values manually** — always use the exact `cursor` from the `X-Pagination-Next` header.
If a cursor has expired or is invalid, restart pagination from the beginning (omit the cursor parameter).
**Best practice:** Always follow the `X-Pagination-Next` header as-is and stop when it's no longer present — you've reached the last page!
## Live Pagination Example
Start by fetching the first page of results (no cursor needed for the first request).
```bash theme={null}
curl -i --request POST \
--url 'https://api.edges.run/v1/actions/linkedin-search-people/run/live' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"parameters": {},
"identity_mode": "auto"
}'
```
Examine the response headers to find pagination info:
* `X-Pagination-Next`: URL with cursor for next page, or `null` if last page
* `X-Pagination-Previous`: URL for previous page (not always present)
Use the **exact URL** from `X-Pagination-Next` header (includes the cursor):
```bash theme={null}
curl -i --request POST \
--url 'https://api.edges.run/v1/actions/linkedin-search-people/run/live?cursor=eyJwYWdlIjoyLCJ0b2tlbiI6ImFiYzEyMyJ9' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--header 'X-API-Key: ' \
--data '{
"parameters": {},
"identity_mode": "auto"
}'
```
Repeat until the `X-Pagination-Next` header is **no longer present** — you've reached the last page.
**Critical:** Always use the exact URL from `X-Pagination-Next`. Cursors expire after 24 hours — if expired, restart from the beginning.
Don't want to handle pagination manually?\
Use **async** or **schedule** modes — Edges will handle pagination and stream results via callbacks.
## Paginating Run Outputs & Inputs
The [`GET /runs/{run_uid}/outputs`](/v1/api/runs/outputs) and [`GET /runs/{run_uid}/inputs`](/v1/api/runs/inputs) endpoints use **cursor-based pagination** by default.
* Use `limit` to control page size (default: **100**, max: **500**).
* Follow the **`X-Pagination-Next`** response header to fetch the next page — it contains the full URL with `limit` and `cursor`.
* Stop when the `X-Pagination-Next` header is **absent** — there are no more pages.
```bash theme={null}
# First page
curl -X GET "https://api.edges.run/v1/runs/{run_uid}/outputs?limit=200" \
-H "X-API-Key: "
# Next page — use the exact URL from X-Pagination-Next
curl -X GET "https://api.edges.run/v1/runs/{run_uid}/outputs?limit=200&cursor=" \
-H "X-API-Key: "
```
The `offset` parameter is **deprecated** on these endpoints. If provided, the system falls back to offset-based pagination and cursor pagination is not used.
## Best Practices Summary
### For Live Mode
* Follow the `X-Pagination-Next` header iteratively until it is **no longer present**
* Always use the exact URL from `X-Pagination-Next` — never construct cursor values manually
* Handle cursor expiration gracefully — restart from the beginning if you receive an error (cursors expire after 24 hours)
### For Async/Schedule Modes
* Set `max_results` parameter to control how many total results you want
* Results are delivered progressively via callbacks as soon as they're processed
* No manual pagination handling required
### For Run Outputs & Inputs
* Follow the `X-Pagination-Next` header — same pattern as live mode
* Use `limit` to control page size (default: 100, max: 500)
* Do not use `offset` — it is deprecated and disables cursor pagination
# Rate Limits
Source: https://docs.edges.run/v1/runs/rate-limits
Learn about rate limits, quotas, and best practices for managing API usage with Edges.
Edges implements rate limits to ensure fair usage and optimal performance for all users.
Understanding these limits helps you design efficient automations and avoid interruptions.
## Overview
Rate limits are applied at multiple levels:
* **API Endpoints**: Per-minute limits on specific API calls
* **Daily Quotas**: Total daily usage limits based on your plan
* **Concurrent Execution**: Limits on parallel automated runs and batch processing
Each plan includes a daily quota that represents your total usage allowance. This quota is consumed by all API calls across your workspace.
## Plan Tiers
Your rate limits are determined by your plan tier, which is based on your monthly credit allocation. You can see your current tier in your [Workspace Settings](https://app.edges.run/settings/plans/credits).
| Plan Tier | Monthly Credits | Description |
| --------- | ----------------------- | --------------------------------------- |
| Trial | 1,000 | Free trial with basic limits |
| Bronze | 2,500 - 10,000 | Starter plans for small teams |
| Silver | 10,001 - 100,000 | Growth plans for scaling teams |
| Gold | 100,001 - 500,000 | Business plans for expanding operations |
| Platinum | 500,001 - 2,000,000 | Scale plans for high-volume operations |
| Diamond | 2,000,001 - 20,000,000 | Advanced plans for large organizations |
| Titanium | 20,000,001 - 50,000,000 | Enterprise plans for maximum scale |
## API Rate Limits
### Real-time Actions
The most important rate limits apply to real-time action execution via `/v1/actions/{action-name}/run/live`.
These limits determine how many requests you can make per minute:
| Plan Tier | Max Requests/Second | Max Requests/Minute |
| ------------------ | ------------------- | ------------------- |
| Trial | 1 | 60 |
| Bronze | 2 | 120 |
| Silver / Gold | 10 | 600 |
| Platinum / Diamond | 20 | 1,200 |
| Titanium | 40 | 1,200 |
For async actions, different concurrent execution limits apply (see [Concurrent Execution](#concurrent-execution) below).
#### Capacity Examples
Assuming an average request duration of 2-3 seconds:
| Plan Tier | Estimated Daily Capacity | Example Use Case |
| ------------------ | ------------------------ | ---------------------- |
| Trial | \~86,400 requests/day | Small-scale testing |
| Bronze | \~172,800 requests/day | Individual prospecting |
| Silver / Gold | \~864,000 requests/day | Team sales operations |
| Platinum / Diamond | \~1,728,000 requests/day | Large-scale enrichment |
| Titanium | \~3,456,000 requests/day | Enterprise automation |
**Example**: With a Silver or Gold plan (600 requests/minute), you can:
* Enrich \~864,000 LinkedIn profiles per day
* Process \~36,000 profiles per hour
* Handle \~600 concurrent enrichment requests
### Identity Management
Rate limits for identity-related operations via `/v1/identities` (create, update, delete, retrieve):
| Plan Tier | Max Operations/Second | Max Operations/Minute |
| ------------------ | --------------------- | --------------------- |
| Trial | 2 | 100 |
| Bronze | 2 | 100 |
| Silver / Gold | 4 | 250 |
| Platinum / Diamond | 5 | 300 |
| Titanium | 8 | 500 |
#### Capacity Examples
For identity operations (create, update, delete):
| Plan Tier | Daily Capacity | Use Case |
| ------------------ | ------------------------ | ------------------------------ |
| Trial | \~144,000 operations/day | Basic account management |
| Bronze | \~144,000 operations/day | Small team setup |
| Silver / Gold | \~360,000 operations/day | Growing organization |
| Platinum / Diamond | \~432,000 operations/day | Large team management |
| Titanium | \~720,000 operations/day | Enterprise identity management |
### Workspace Info
Rate limits for workspace data retrieval via `/v1/workspaces`:
| Plan Tier | Max Requests/Second | Max Requests/Minute |
| ------------------ | ------------------- | ------------------- |
| Trial | \< 1 | 5 |
| Bronze | \< 1 | 10 |
| Silver / Gold | 1 | 50 |
| Platinum / Diamond | 1 | 75 |
| Titanium | 2 | 100 |
### Run's Routes Limits
To date, all /runs/xxx routes are subject to the same limit (e.g., 30 requests/minute for TRIAL plans). We are working to refine these quotas per endpoint (status, output, etc.) to better match usage patterns. Plans and limits will be updated in the documentation as soon as these changes take effect.
| Plan Tier | Max Requests/Second | Max Requests/Minute | Rationale |
| ------------------ | ------------------- | ------------------- | ------------------------------------------------------- |
| Trial | \< 1 | 30 | Supports 2 concurrent runs @ 10s polling interval |
| Bronze | 1 | 60 | Supports 2 concurrent runs with more aggressive polling |
| Silver / Gold | 2.5 | 150 | Supports 5 concurrent runs @ 10s polling interval |
| Platinum / Diamond | 5 | 300 | Supports 10 concurrent runs @ 10s polling interval |
| Titanium | 10 | 600 | Supports 15 concurrent runs @ 10s polling interval |
Rate limits for polling run results via `/v1/runs/{run_uid}/outputs`. These limits support realistic polling patterns for customers who prefer polling over callbacks.
These limits are aligned with concurrent execution limits. For example, with a Silver/Gold plan (5 concurrent runs), you can poll all active runs every 10 seconds with comfortable headroom.
#### Capacity Examples
| Plan Tier | Polling Capacity | Use Case |
| ------------------ | ---------------------------------------- | -------------------------------- |
| Trial | Poll 2 runs every 10s | Basic polling during development |
| Bronze | Poll 2 runs every 10s with headroom | Small-scale polling |
| Silver / Gold | Poll 5 runs every 10s, or 1 run every 4s | Team polling operations |
| Platinum / Diamond | Poll 10 runs every 10s | Multi-workspace polling |
| Titanium | Poll 15 runs every 10s | Enterprise-scale polling |
**Implementation Details:**
* Rate limit type: Per-workspace, per-minute
* Error response: Standard 429 with `X-RateLimit-Type: /v1/runs/outputs`
* Headers include `X-RateLimit-Remaining` for visibility
## Concurrent Execution
For async runs via `/v1/actions/{action-name}/run/async`, we limit the number of concurrent runs and batch processing:
| Plan Tier | Max Concurrent Runs | Max Batches per Run |
| ------------------ | ------------------- | ------------------- |
| Trial / Bronze | 2 | 2 |
| Silver / Gold | 5 | 3 |
| Platinum / Diamond | 10 | 5 |
| Titanium | 15 | 8 |
**What this limits:** Concurrent Runs cap how many runs Edges *processes at once*, not how many you can submit. You can submit as many runs as you need; extra runs are queued and start automatically when a slot is freed up.
**Batching:** Each batch contains maximum **15 inputs**. Batches within a run are executed in parallel (up to "Max Batches per Run"); multiple runs can execute concurrently up to your plan's "Max Concurrent Runs".
For example: one run of 35 inputs → 3 batches (2×15 + 1x5) in parallel for that run.
**Example — \~1,800 inputs:**
| Plan Tier | Approximate duration |
| ------------------ | -------------------- |
| Silver / Gold | \~10–15 min |
| Platinum / Diamond | \~5–8 min |
| Titanium | \~4–5 min |
#### Capacity Examples
For async automations with concurrent execution:
| Plan Tier | Estimated Daily Capacity | Use Case |
| ------------------ | ------------------------------- | ---------------------- |
| Trial / Bronze | \~50,000-100,000 records/day | Basic automation |
| Silver / Gold | \~200,000-500,000 records/day | Team automations |
| Platinum / Diamond | \~500,000-1,000,000 records/day | Large-scale automation |
| Titanium | 1,000,000+ records/day | Enterprise automations |
**Example**: With a Platinum or Diamond plan (10 concurrent runs, 5 batches each):
* Process \~500,000-1,000,000 records per day
* Handle complex automations with large results
* Scale to enterprise-level automation needs
## Engagement Mode Rate Limits
For identities configured in **engagement mode**, a separate rate-limiting system applies. These limits are based on the number of **active** engagement identities in your workspace, not your credit-based plan tier.
Engagement mode identities are designed for LinkedIn automation workflows that don't consume credits. Because of this, dedicated rate limits ensure fair usage across all users.
More about what's an active engagement identity [here](/v1/identities/engagement#when-is-an-engagement-identity-active-or-inactive)
### Rate Limits by Identity Count
| Identities | `/v1/actions` (calls/min) | `/v1/actions` (calls/sec) | `/v1/identities` | `/v1/workspaces` | Max Concurrent Runs | Daily API Limit | Batches per Run |
| ---------------- | ------------------------- | ------------------------- | ---------------- | ---------------- | ------------------- | --------------- | --------------- |
| **1–50** | 25 | 0.4 | 100 | 10 | 2 | 720,000 | 2 |
| **51–200** | 50 | 0.8 | 300 | 30 | 6 | 3,600,000 | 6 |
| **201–1,000** | 250 | 4.2 | 600 | 60 | 12 | 14,400,000 | 12 |
| **1,001–5,000** | 1,250 | 20.8 | 1,000 | 100 | 20 | 72,000,000 | 20 |
| **5,001–10,000** | 2,400 (cap) | 40 | 1,000 | 100 | 20 | 72,000,000 | 20 |
As your engagement identity count grows, your rate limits automatically scale up to support higher volumes.
### Understanding Engagement Limits
* **`/v1/actions`**: Controls how many action requests you can make per minute/second
* **`/v1/identities`**: Maximum operations per minute for identity management
* **`/v1/workspaces`**: Maximum workspace info requests per minute
* **Max Concurrent Runs**: Number of async runs that can execute in parallel
* **Daily API Limit**: Total API calls allowed per day across all endpoints
* **Batches per Run**: Maximum batches allowed per async run
If you have both engagement identities and a credit-based plan, the higher limit between the two systems applies for each endpoint.
## Best Practices
### Optimizing for Rate Limits
1. **Use Async Mode for High Volume**: When processing large datasets, use async mode to benefit from concurrent execution limits rather than hitting real-time rate limits.
2. **Batch Your Requests**: Group related operations together to minimize API calls.
3. **Implement Exponential Backoff**: When you hit rate limits, wait before retrying with increasing delays.
4. **Monitor Your Usage**: Track your API consumption to stay within limits.
### Handling Rate Limit Errors
When you exceed rate limits, you'll receive a `429 Too Many Requests` response.
```json theme={null}
{
"error": {
"code": 429,
"status": "Too Many Requests",
"details": {
"Retry-After": "60",
"X-RateLimit-Limit": "2",
"X-RateLimit-Reset": "1754402101",
"X-RateLimit-Type": "/v1/actions"
},
"message": "Rate limit exceeded (/v1/actions)"
}
}
```
### Other Limit Errors to handle
In addition to internal Edges rate limits, you may encounter **LinkedIn-originated rate limits**, which we proactively detect and surface with standardized errors. These are not caused by Edges infrastructure but reflect **LinkedIn’s own protective mechanisms**.
| Error Type | `status_code` | `error_label` | Origin |
| ---------- | ------------- | --------------- | ----------------------------------------- |
| Internal | `429` | *n/a* | Edges API |
| Detected | `429` | `LIMIT_REACHED` | LinkedIn (with protection logic in Edges) |
| Passive | `429` | `STATUS_429` | LinkedIn (propagated, no guardrails) |
**Handling Strategy (All Cases):**
* Implement **exponential backoff** before retrying
* Monitor for recurring errors per identity
* Avoid retrying immediately and let an extended cooldown period elapse
#### Differentiating `LIMIT_REACHED` with `appendix`
`LIMIT_REACHED` errors now include a **`params.appendix`** (and **`params.timespan`**) so you can tell which limit was hit:
| Origin | `params.appendix` | `params.timespan` | Meaning |
| --------------- | ----------------- | ----------------- | ------------------------------------------- |
| Third-party API | `API_FUSE_LIMIT` | `Daily` | Daily quota reached (e.g. provider fuse) |
| Third-party API | `API_RATE_LIMIT` | `Minute` | Rate limit or flood detection (per minute) |
| Product | `MINUTE_LIMIT` | `Minute` | Per-minute product limit (calls per minute) |
| Product | `DAILY_LIMIT` | `Daily` | Daily product limit |
Use **`appendix`** to choose the right retry strategy (e.g. wait until next minute vs next day). Integrations that only check the `LIMIT_REACHED` label still work but should add handling based on **`appendix`** and **`timespan`** for better behavior.
For **`linkedin-search-people`** in async mode, runs that hit a **monthly** LinkedIn limit (`LIMIT_REACHED`) are automatically retried when the limit resets instead of failing permanently.
`LIMIT_REACHED` errors are triggered by **Smart Limits** — Edges tracks LinkedIn activity on a 24-hour sliding window to prevent account restrictions. [Learn more about Smart Limits](/v1/linkedin/limits).
This rate limit error response uses a different structure than our standard error format. For details on our typical error responses, see our [Error Reference](/v1/error-reference).
## Plan-Specific Considerations
### Trial and Bronze
* Focus on development and testing
* Use async mode for production workloads
* Monitor usage closely to avoid interruptions
### Silver, Gold, Platinum, and Diamond
* Suitable for production workloads
* Balance between real-time and async execution
* Consider upgrading for higher volume needs
### Titanium
* Designed for enterprise-scale operations
* Maximum concurrent execution capabilities
* Contact support for custom limits if needed
## Monitoring and Alerts
Track your rate limit usage through:
* API response headers
* Dashboard analytics
* Webhook notifications for quota warnings
## Getting Help
If you consistently hit rate limits or need higher limits:
1. **Review your implementation design** for optimization opportunities
2. **Consider upgrading your plan** for higher limits
3. **Contact support** for custom enterprise solutions
For detailed information about your current plan's limits, check your workspace dashboard or contact our support team.
# Managing Schedules
Source: https://docs.edges.run/v1/runs/schedules
Create, list, retrieve, update, pause, resume, and delete schedules.
This guide explains how to create, list, retrieve, update, pause, resume, and delete schedules using the Edges API.
## Creating a Schedule
* Use the API to schedule an action by calling the appropriate action's `/schedule` endpoint (e.g., `/v1/actions/{action-name}/schedule`).
* You can schedule a one-time run in the future, or set up a recurring schedule using a cron expression.
**Parameters:**
* `inputs`: The inputs for your action (array).
* `callback`: Object with a `url` (required) to receive results.
* `cron`: (optional) POSIX cron expression for recurring schedules.
* `schedule_at`: (optional) ISO8601 date-time for a one-shot schedule.
* `timezone`: (optional) IANA timezone string (e.g., "Europe/Paris").
#### Example: Create a recurring schedule
```bash theme={null}
curl -X POST "https://api.edges.run/v1/actions/{action-name}/schedule" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json" \
-d '{
"inputs": [ ... ],
"callback": { "url": "https://yourdomain.com/callback" },
"cron": "0 8 * * 1", // Every Monday at 8am
"timezone": "Europe/Paris"
}'
```
#### Example: Create a one-time schedule
```bash theme={null}
curl -X POST "https://api.edges.run/v1/actions/{action-name}/schedule" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json" \
-d '{
"inputs": [ ... ],
"callback": { "url": "https://yourdomain.com/callback" },
"schedule_at": "2024-07-01T10:00:00Z"
}'
```
## Creating CRON Expressions
A CRON expression is a string used to define the schedule for recurring jobs. It consists of five fields separated by spaces, representing:
1. Minute (0-59)
2. Hour (0-23)
3. Day of month (1-31)
4. Month (1-12)
5. Day of week (0-6, where 0 = Sunday)
**Examples:**
* `0 9 * * 1-5` — Every weekday (Monday to Friday) at 9:00 AM
* `30 2 * * *` — Every day at 2:30 AM
* `0 0 1 * *` — On the first day of every month at midnight
* `*/30 * * * *` — Every 30 minutes
You can use online tools like [crontab.guru](https://crontab.guru/) to build and test your CRON expressions.
## Listing Schedules
* Use [`GET /v1/schedules`](/v1/api/schedules) to retrieve all schedules.
* You can filter by `status`, `action_name`, `user_uid`, `workspace_uid`, and more. Pagination is supported via `limit` and `offset`. Sorting is available using the `sort` parameter (prefix with `-` for descending order).
#### Example: List all active schedules for a workspace
```bash theme={null}
curl -X GET "https://api.edges.run/v1/schedules?status=ACTIVE&workspace_uid=&limit=20&sort=-next_execution_at" \
-H "Accept: application/json" \
-H "X-API-Key: "
```
When using the sandbox, the workspace UID will be different from your main workspace.
## Getting a Specific Schedule
* Use [`GET /v1/schedules/{scheduled_run_uid}`](/v1/api/schedules/get) with the schedule UID to fetch details.
#### Example: Get a schedule by UID
```bash theme={null}
curl -X GET "https://api.edges.run/v1/schedules/{scheduled_run_uid}" \
-H "Accept: application/json" \
-H "X-API-Key: "
```
## Managing a Schedule (Pause, Resume, Cancel)
* Use [`POST /v1/schedules/{scheduled_run_uid}/{action}`](/v1/api/schedules/manage) to update a schedule's status.
* Actions: `pause`, `resume`, `cancel`.
#### Example: Pause a schedule
```bash theme={null}
curl -X POST "https://api.edges.run/v1/schedules/{scheduled_run_uid}/pause" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json"
```
#### Example: Resume a schedule
```bash theme={null}
curl -X POST "https://api.edges.run/v1/schedules/{scheduled_run_uid}/resume" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json"
```
#### Example: Cancel (delete) a schedule
```bash theme={null}
curl -X POST "https://api.edges.run/v1/schedules/{scheduled_run_uid}/cancel" \
-H "Accept: application/json" \
-H "X-API-Key: " \
-H "Content-Type: application/json"
```
## Updating a Schedule
* To update timing or inputs, cancel the existing schedule and create a new one with the desired parameters.
***
See the [API Reference](/v1/api/schedules) for detailed endpoint usage, parameters, and more examples.
# SDK Setup
Source: https://docs.edges.run/v1/sdk
Official TypeScript SDK for interacting with the Edges API.
This SDK provides a unified interface to interact with Edges's API using a single entry point: the `Edges` class. It simplifies authentication and gives access to the `core` api and multiple integrations such as `linkedin`, and `salesnavigator`.
## ✨ Features
* Unified `Edges` interface
* Individual API clients: `core`, `linkedin`, `salesnavigator`, etc.
* Auto-generated TypeScript types for safety and autocompletion
* Built using [OpenAPI Generator](https://openapi-generator.tech/) with the `typescript-fetch` generator and custom templates
* Supports modern async/await and Fetch API
* Supports ES6 Language level (es2019 and newer)
* Supports CommonJS and ES6 module systems
* Can be used in both Typescript and Javascript. In TypeScript, the definition will be automatically resolved via `package.json`. ([Reference](https://www.typescriptlang.org/docs/handbook/declaration-files/consumption.html))
## 📦 Installation
```bash theme={null}
npm install @edgesrun/sdk --save
# or
yarn add @edgesrun/sdk
# or for this version
npm install {{npmName}}@{{npmVersion}} --save
```
## 🔐 Authentication
Each user has their own unique API Key tied to their account. API Keys are not shared across the workspace.
To get your API Key:
1. Log into the [Edges Platform](https://app.edges.run)
2. Go to [**Developer Settings**](https://app.edges.run/settings/developers)
3. Copy your API Key
## 🚀 Usage
### Basic Usage
```ts theme={null}
import { Edges } from '@edgesrun/sdk';
// Initialize the SDK with your API Key
const EDGES_API_KEY = "your_api_key"; // for production code, you should use environment variables and add proper check
const ed = new Edges({ apiKey: EDGES_API_KEY });
// Example: Use the Core client
const workspaceResponse = await ed.core.getWorkspaces();
console.log(workspaceResponse.data);
// Example: Use the LinkedIn client
const { data: profile } = await ed.linkedin.extractPeople({ input: {linkedin_profile_url: "https://uk.linkedin.com/in/philip-wookey-8642939b"} });
console.log(profile);
// Example: Use the Sales Navigator client
// !!!You need a linkedin account with an active Sales Navigator subscription!!!
const params = {
input: {
sales_navigator_profile_search_url: "https://www.linkedin.com/sales/search/people?query=(...)"
},
parameters: {
exclude_crm_contacts: true,
exclude_viewed_leads: true
}
}
const searchResults = await ed.salesnavigator.searchPeople(params);
console.log(searchResults);
```
### Responses
All SDK operations return an enhanced Response wrapper that provides access to the full HTTP response as well as convenience methods to work with its content and metadata.
This design allows you to:
* Inspect HTTP status, headers, and success flags
* Parse and access the response body easily
* Handle paginated endpoints with built-in pagination helpers
The returned object includes:
| Property | Description |
| -------------- | ----------------------------------------------------------------------------------------------- |
| `raw` | The native `fetch` `Response` object, with full access if needed |
| `status` | HTTP status code (e.g., `200`, `404`) |
| `statusText` | HTTP status text (e.g., `"OK"`, `"Not Found"`) |
| `ok` | Boolean indicating if `status` is in the range 200–299 |
| `headers` | The native `Response.headers` object – use `.get()` to retrieve header values |
| `previousPage` | The value of the `X-Pagination-Previous` header, or `null` if not present |
| `nextPage` | The value of the `X-Pagination-Next` header containing the cursor URL, or `null` if not present |
| `data` | The parsed body of the response (lazily evaluated on first access) |
For paginated endpoints, `nextPage` contains a URL with a `cursor` parameter. Use this URL directly for the next request. Cursors expire after 24 hours. See the [Pagination Guide](/v1/runs/pagination) for details.
```ts theme={null}
// Full response object with metadata and parsed body
const profileRes = await ed.linkedin.extractPeople({
input: { linkedin_profile_url: "https://uk.linkedin.com/in/jouni-paavola-1ba10063" }
});
// Accessing status information
console.log(profileRes.status); // e.g., 200
console.log(profileRes.statusText); // e.g., "OK"
console.log(profileRes.ok); // true if status is 2xx
// Accessing response headers (native fetch Headers object)
console.log(profileRes.headers.get("Content-Type"));
// Using pagination headers
console.log(profileRes.previousPage);
console.log(profileRes.nextPage);
// Accessing parsed response body
console.log(profileRes.data);
// Convenient destructuring when you only need the data
const { data: profile } = await ed.linkedin.extractPeople({
input: { linkedin_profile_url: "https://www.linkedin.com/in/lee-swepston-4367b628/" }
});
console.log(profile);
```
> 💡 Use the `ok` flag to easily gate logic on successful requests:
```ts theme={null}
const res = await ed.linkedin.extractPeople({ input });
if (!res.ok) {
throw new Error(`Request failed with status ${res.status}`);
}
console.log(res.data);
```
This gives you fine-grained control over both successful and unsuccessful responses, while keeping your codebase clean and predictable.
### Error handling
API calls can fail, and production-ready code should always handle errors properly.
When an error occurs, the SDK throws a `ResponseError`, which extends the native `Error` object and adds:
* `response`: the raw Fetch Response object
* `body`: the decoded API error body (already parsed from JSON)
```ts theme={null}
try {
const profileRes = await ed.linkedin.extractPeople({ input: {linkedin_profile_url: "https://www.linkedin.com/in/john-doe"} });
console.log(profileRes.data);
} catch(error) {
console.error("[ERR] Extract People", error.message, error.response.status);
console.error(error.body);
}
```
The `body` follows the API error definition. For more details, check [about errors in the API doc](https://docs.edges.run/v1/faq-troubleshooting#troubleshooting-errors).
Each error response includes:
* `error_label`: A machine-readable identifier for the error type
* `error_scope`: Indicates which part of the request caused the error (e.g., "input", "auth", "server")
* `error_ref`: A unique reference code for tracking and debugging
* `message`: A human-readable description of the error
* `status_code`: The HTTP status code
* `params`: Additional error parameters (if any)
Common HTTP status codes:
* `200`: The request was successful (some API calls may return 201 instead)
* `400`: Bad Request - Invalid input or parameters
* `401`: Unauthorized - Invalid or missing API key
* `403`: Forbidden - Insufficient permissions
* `404`: Not Found - Resource doesn't exist
* `500`: Internal Server Error - Server-side issue
Always check the `error_label` and `error_scope` fields to programmatically handle different types of errors in your application.
If you encounter an unusual error, such as a 500 or 503, feel free to reach out! These are internal errors on our end, and we're
happy to help resolve them.
### Async execution mode Usage
All the actions that can benefit of being executed in async mode will have "Async" suffixed methods, corresponding to the API async endpoints
(for example [Extract LinkedIn People Async](https://docs.edges.run/v1/api/actions/linkedin-extract-people-async)).
This means a few things for the expected params:
* `inputs`: you can now pass an array of `input` to batch fetch the results
* `callback`:
* `url`: the url, on your side, where we will stream you the results
* `headers`: an array of `{ name: string, value: string}` header's definitions we will include on each call of your url
Your url will receive the following payload format:
```json theme={null}
{
"run": {
"run_uid": "string",
"batch_uid": "string",
"status": "CREATED" || "INVALID" || "QUEUED" || "SCHEDULED" || "BLOCKED" || "STOPPED" || "RUNNING" || "FAILED" || "PARTIAL_SUCCEEDED" || "SUCCEEDED",
},
"input": {} || null,
"custom_data": {} || null,
"error": {} || null,
"results": [] || null
}
```
Example of an `async` call:
```javascript theme={null}
const inputs = [
{ linkedin_profile_url: "https://it.linkedin.com/in/nair-marques-3459748a" },
{ linkedin_profile_url: "https://lv.linkedin.com/in/innadjeri" }
];
const result = await ed.linkedin.extractPeopleAsync({
inputs,
callback: {
url: "https://your.callback.url.app.com/from-sdk",
headers: [
{ name: "Authorization", value: "your-token" },
{ name: "greetings", value: "Coucou from France" }
]
}
});
// Let's wait for results on your callback url!
```
where:
* `input` match the input of the corresponding *live* action
* `error` match the error format (see "Error handling")
* `results` is an array of results that match the response format of the corresponding *live* action
A new callback is issued for each input or page when results span multiple pages.
You can process results as they arrive to keep your platform load low and distributed over time.
To limit the number of results, use the `parameters.max_results` parameter available on relevant actions.
### Schedule execution mode Usage
All the actions that can benefit of being executed in schedule mode will have "Schedule" suffixed methods, corresponding to the API schedule endpoints
(for example [Extract LinkedIn People Schedule](https://docs.edges.run/v1/api/actions/linkedin-extract-people-schedule)).
Basically, it is an async execution, so it shares all the async specifics described above, but we added some params to plan future executions:
* `schedule_at`: [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime. It will define the next execution date (defaults to UTC). If you use a `cron` expression the recurrence will start at the first occurence after this datetime
* `cron`: a `* * * * *` [cron format expression](https://en.wikipedia.org/wiki/Cron) to schedule repeated executions. By default it will be UTC based and start to evaluate immediately (use `schedule_at` if you want to delay).
* `timezone`: [IANA timezone](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) to evaluate the `cron` expression. Note that it is not compatible with `schedule_at` that will always use the timezone of the datetime expression
CRON intervals below 15 minutes are currently blocked. Contact support if you require shorter intervals for real-time use cases.
Example of a `schedule` call:
```javascript theme={null}
const inputs = [
{linkedin_profile_url: "https://uk.linkedin.com/in/martin-stevens-a7176965"},
{linkedin_profile_url: "https://ch.linkedin.com/in/ptlugonarantes"}
];
const result = await ed.linkedin.extractPeopleSchedule({
inputs,
callback: {
url: "https://your.callback.url.app.com/edges",
headers: [
{ name: "Authorization", value: "your-token" },
{ name: "greetings", value: "Coucou from France" }
]
},
// Schedule specific params
schedule_at: "2100-06-26T13:10:58+02:00",
cron: "0 7 * * *",
timezone: "Europe/Paris"
});
```
### Account Rotation
Actions are performed over third-party services, the integrations (LinkedIn, Sales Navigator,...). Most of the time, those services need
authenticated accounts to be able to do their job.
If you're new to Edges, we strongly recommend reviewing the following resources before diving into the API and the SDK:
* [Quickstart](https://docs.edges.run/v1/quickstart) – A brief overview of how to use the API.
* [Core Concepts](https://docs.edges.run/v1/core-concepts) – A description of core objects and how to interact with them.
You need to have at least one [identity](https://app.edges.run/identities) connected to an integration account corresponding to
the actions you want to use.
For example, to perform LinkedIn actions, you have to connect a valid [LinkedIn integration](https://app.edges.run/integrations/linkedin)
to an [identity](https://app.edges.run/identities).
By default, action calls will try to find the appropriate accounts on your workspace and dispatch the load over them: this is called account
rotation and is proven usefull to run a bunch of actions like batch data enrichments.
The `identity_ids` body param is an array of identity uids that allows you to better control the identities used to execute your call. You can
then dedicate some identities and their integration accounts to specific tasks.
### Core methods
The core scope (`Edges.core`) provides methods to manage operational entities used by the Edges platform.
Available methods include:
* **Identities**: The building blocks of integration management
* **Integrations**: Connections to third-party platforms that enable action execution
* **Schedules, runs, and callbacks**: Insights into platform activities and triggered operations
* Additional methods are continuously being added as the platform evolves
To better understand how Edges allows you to build great things, be sure to take a look at the [Quickstart guide](https://docs.edges.run/v1/quickstart)
and a deeper explanation of our [Core Concepts](https://docs.edges.run/v1/core-concepts).
## 🧠 SDK Structure
The Edges API allows you to interact with various third-party services through integrations (LinkedIn, Sales Navigator, and more).
Actions available for each integration are exposed through dedicated scoped clients.
```ts theme={null}
const ed = new Edges({ apiKey: 'your_api_key_here' });
ed.core // Core platform endpoints (identities, workspaces, etc.)
ed.linkedin // LinkedIn-specific actions
ed.salesnavigator // Sales Navigator-specific actions
```
Scopes are always lower case alpha identifiers.
These actions correspond to the action names found in the [API Reference](https://docs.edges.run/v1/api/introduction)
or [Edges SaaS](https://app.edges.run/actions), with integration identifier prefixes removed.
## 📘 API Reference
The full API reference is available at: [Edges API Docs](https://docs.edges.run/v1/api/introduction)
This SDK is auto-generated from our OpenAPI specification.
A full **SDK reference** is also auto-generated under the installed package `docs/` if needed.
## ❓ FAQ
Q: Can I use this SDK in Node.js and browser environments?
A: Yes! It supports both environments as it is based on fetch. For Node.js, make sure to install a polyfill like node-fetch.
# Archive LinkedIn Message
Source: https://docs.edges.run/v1/api/actions/linkedin-archive-message
v1/api/actions.json post /actions/linkedin-archive-message/run/live
Archive a LinkedIn conversation using its thread ID.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Provide a **`linkedin_thread_id`** (or a LinkedIn messaging thread URL). You can retrieve thread IDs from [Extract LinkedIn Conversations](/v1/api/actions/linkedin-extract-conversations) or [Extract LinkedIn Messages](/v1/api/actions/linkedin-extract-messages).
# Archive LinkedIn Message Async
Source: https://docs.edges.run/v1/api/actions/linkedin-archive-message-async
v1/api/actions.json post /actions/linkedin-archive-message/run/async
Archive a LinkedIn conversation asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Provide a **`linkedin_thread_id`** (or a LinkedIn messaging thread URL). You can retrieve thread IDs from [Extract LinkedIn Conversations](/v1/api/actions/linkedin-extract-conversations) or [Extract LinkedIn Messages](/v1/api/actions/linkedin-extract-messages).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Archive LinkedIn Message Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-archive-message-schedule
v1/api/actions.json post /actions/linkedin-archive-message/run/schedule
Schedule archiving a LinkedIn conversation at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Provide a **`linkedin_thread_id`** (or a LinkedIn messaging thread URL). You can retrieve thread IDs from [Extract LinkedIn Conversations](/v1/api/actions/linkedin-extract-conversations) or [Extract LinkedIn Messages](/v1/api/actions/linkedin-extract-messages).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Connect LinkedIn Profile
Source: https://docs.edges.run/v1/api/actions/linkedin-connect-profile
v1/api/actions.json post /actions/linkedin-connect-profile/run/live
Send a connection request to a LinkedIn profile with an optional personalized message.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Connect LinkedIn Profile Async
Source: https://docs.edges.run/v1/api/actions/linkedin-connect-profile-async
v1/api/actions.json post /actions/linkedin-connect-profile/run/async
Send a connection request to a LinkedIn profile asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Daily connection limit:** Connection requests are capped at **25 per day** per identity.
If a run includes **more than 25 inputs**, Edges processes the **first 25** that day, then **postpones** the rest. The next **batch of up to 25** is processed **one day later**, and this repeats until every input has been handled.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Connect LinkedIn Profile Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-connect-profile-schedule
v1/api/actions.json post /actions/linkedin-connect-profile/run/schedule
Schedule sending a connection request to a LinkedIn profile at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Daily connection limit:** Connection requests are capped at **25 per day** per identity.
If a run includes **more than 25 inputs**, Edges processes the **first 25** that day, then **postpones** the rest. The next **batch of up to 25** is processed **one day later**, and this repeats until every input has been handled.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Download a LinkedIn Attachment
Source: https://docs.edges.run/v1/api/actions/linkedin-download-attachment
v1/api/actions.json get /actions/linkedin-download-attachment
Download a file attachment from a LinkedIn message conversation.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
To download attachments, first use the [Extract LinkedIn Messages](/v1/api/actions/linkedin-extract-messages) action to get the attachment URLs.
Make sure to use the same `identity_id` for both actions.
# Extract LinkedIn Company Affiliates
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-affiliates
v1/api/actions.json post /actions/linkedin-extract-company-affiliates/run/live
Extract the list of affiliated companies (subsidiaries, parent companies) linked to a LinkedIn company page.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract LinkedIn Company Affiliates Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-affiliates-async
v1/api/actions.json post /actions/linkedin-extract-company-affiliates/run/async
Extract affiliated companies from a LinkedIn company page asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Company Affiliates Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-affiliates-schedule
v1/api/actions.json post /actions/linkedin-extract-company-affiliates/run/schedule
Schedule extraction of affiliated companies from a LinkedIn company page at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Company Employees Insights
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-employees-insights
v1/api/actions.json post /actions/linkedin-extract-company-employees-insights/run/live
Extract employee insights and analytics from a LinkedIn company page, including headcount by function, location, and seniority.
This Action extracts employee insights data from LinkedIn company pages, such as the [Clay's People Insights page](https://www.linkedin.com/company/grow-with-clay/people/).
**Default Behavior:** This Action extracts data **only for the main company**, giving you more control and accuracy over the results.
**LinkedIn's Behavior:** Data is displayed for **both the company and all its affiliates**.
**To replicate LinkedIn's behavior:** Set `parameters.affiliates` to `true`. This will include data for the company **and** all its affiliates.
**For complete affiliate data:** Use the dedicated [Extract LinkedIn Company Affiliates](/v1/api/actions/linkedin-extract-company-affiliates) Action to get the full list of affiliates, then extract detailed data for each one.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract LinkedIn Company Employees Insights Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-employees-insights-async
v1/api/actions.json post /actions/linkedin-extract-company-employees-insights/run/async
Extract employee insights from a LinkedIn company page asynchronously. Results are delivered via callback.
This Action extracts employee insights data from LinkedIn company pages, such as the [Clay's People Insights page](https://www.linkedin.com/company/grow-with-clay/people/).
**Default Behavior:** This Action extracts data **only for the main company**, giving you more control and accuracy over the results.
**LinkedIn's Behavior:** Data is displayed for **both the company and all its affiliates**.
**To replicate LinkedIn's behavior:** Set `parameters.affiliates` to `true`. This will include data for the company **and** all its affiliates.
**For complete affiliate data:** Use the dedicated [Extract LinkedIn Company Affiliates](/v1/api/actions/linkedin-extract-company-affiliates) Action to get the full list of affiliates, then extract detailed data for each one.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Company Employees Insights Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-employees-insights-schedule
v1/api/actions.json post /actions/linkedin-extract-company-employees-insights/run/schedule
Schedule extraction of employee insights from a LinkedIn company page at a specific time or on a recurring basis.
This Action extracts employee insights data from LinkedIn company pages, such as the [Clay's People Insights page](https://www.linkedin.com/company/grow-with-clay/people/).
**Default Behavior:** This Action extracts data **only for the main company**, giving you more control and accuracy over the results.
**LinkedIn's Behavior:** Data is displayed for **both the company and all its affiliates**.
**To replicate LinkedIn's behavior:** Set `parameters.affiliates` to `true`. This will include data for the company **and** all its affiliates.
**For complete affiliate data:** Use the dedicated [Extract LinkedIn Company Affiliates](/v1/api/actions/linkedin-extract-company-affiliates) Action to get the full list of affiliates, then extract detailed data for each one.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Company Viewers
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-viewers
v1/api/actions.json post /actions/linkedin-extract-company-viewers/run/live
Extract the list of people who have viewed a LinkedIn company page recently.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
## Requirements
The connected LinkedIn identity must be **admin of the page**. Otherwise, the action returns a 424 error: *"The provided account is not allowed to view the analytics of this organization. The account must be admin of the organization."*
The page must be **Premium**. If the page is not premium, the action returns a 424 error: *"The provided account is allowed to view the analytics of this organization but the page is not premium. Please upgrade the page to access this data."*
## Limitations
* Only viewers from the **past year** are extracted.
# Extract LinkedIn Company Viewers Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-viewers-async
v1/api/actions.json post /actions/linkedin-extract-company-viewers/run/async
Extract LinkedIn company page viewers asynchronously with automatic pagination. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
## Requirements
The connected LinkedIn identity must be **admin of the page**. Otherwise, the action returns a 424 error: *"The provided account is not allowed to view the analytics of this organization. The account must be admin of the organization."*
The page must be **Premium**. If the page is not premium, the action returns a 424 error: *"The provided account is allowed to view the analytics of this organization but the page is not premium. Please upgrade the page to access this data."*
## Limitations
* Only viewers from the **past year** are extracted.
# Extract LinkedIn Company Viewers Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-company-viewers-schedule
v1/api/actions.json post /actions/linkedin-extract-company-viewers/run/schedule
Schedule extraction of LinkedIn company page viewers at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
## Requirements
The connected LinkedIn identity must be **admin of the page**. Otherwise, the action returns a 424 error: *"The provided account is not allowed to view the analytics of this organization. The account must be admin of the organization."*
The page must be **Premium**. If the page is not premium, the action returns a 424 error: *"The provided account is allowed to view the analytics of this organization but the page is not premium. Please upgrade the page to access this data."*
## Limitations
* Only viewers from the **past year** are extracted.
# Extract LinkedIn Connections
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-connections
v1/api/actions.json post /actions/linkedin-extract-connections/run/live
Extract the list of your LinkedIn connections with their profile information.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Connections Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-connections-async
v1/api/actions.json post /actions/linkedin-extract-connections/run/async
Extract your LinkedIn connections asynchronously with automatic pagination. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Incremental Sync supported.** This action supports `sync_mode: "incremental"` in the `parameters` object. Requires an [Engagement Identity](/v1/identities/engagement).
* The first run performs a **full sync** (limited by `max_results`).
* Subsequent runs via [`POST /v1/runs/{run_uid}/continue`](/v1/api/runs/continue) return **only new data** since the last retrieval.
* See the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode) for details and limitations.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Connections Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-connections-schedule
v1/api/actions.json post /actions/linkedin-extract-connections/run/schedule
Schedule extraction of your LinkedIn connections at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Incremental Sync supported.** This action supports `sync_mode: "incremental"` in the `parameters` object. Requires an [Engagement Identity](/v1/identities/engagement).
* The first iteration performs a **full sync** (limited by `max_results`).
* Each subsequent scheduled iteration automatically returns **only new data** since the last retrieval.
* If the previous run is still in progress when the next iteration triggers, that iteration will be **skipped**.
* See the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode) for details and limitations.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Conversations
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-conversations
v1/api/actions.json post /actions/linkedin-extract-conversations/run/live
Extract the list of messaging conversations from your LinkedIn inbox.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Conversations Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-conversations-async
v1/api/actions.json post /actions/linkedin-extract-conversations/run/async
Extract LinkedIn messaging conversations asynchronously with automatic pagination. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Conversations Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-conversations-schedule
v1/api/actions.json post /actions/linkedin-extract-conversations/run/schedule
Schedule extraction of LinkedIn messaging conversations at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Followers
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-followers
v1/api/actions.json post /actions/linkedin-extract-followers/run/live
Extract the list of people who follow your LinkedIn profile.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Followers Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-followers-async
v1/api/actions.json post /actions/linkedin-extract-followers/run/async
Extract your LinkedIn followers asynchronously with automatic pagination. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Followers Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-followers-schedule
v1/api/actions.json post /actions/linkedin-extract-followers/run/schedule
Schedule extraction of your LinkedIn followers at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Group Members Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-group-members-schedule
v1/api/actions.json post /actions/linkedin-extract-group-members/run/schedule
Schedule extraction of LinkedIn group members at a specific time or on a recurring basis.
This action allows you to extract members from a LinkedIn group. You need to be a member of the group to extract its members.
LinkedIn limits group member extraction to 10k members. If the group has more than 10k members, only the first 10k will be returned.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Messages
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-messages
v1/api/actions.json post /actions/linkedin-extract-messages/run/live
Extract messages from a specific LinkedIn conversation including text, timestamps, and sender information.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Messages Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-messages-async
v1/api/actions.json post /actions/linkedin-extract-messages/run/async
Extract LinkedIn conversation messages asynchronously with automatic pagination. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Incremental Sync supported.** This action supports `sync_mode: "incremental"` in the `parameters` object. Requires an [Engagement Identity](/v1/identities/engagement).
* The first run performs a **full sync** (limited by `max_results`).
* Subsequent runs via [`POST /v1/runs/{run_uid}/continue`](/v1/api/runs/continue) return **only new data** since the last retrieval.
* See the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode) for details and limitations.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Messages Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-messages-schedule
v1/api/actions.json post /actions/linkedin-extract-messages/run/schedule
Schedule extraction of LinkedIn conversation messages at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Incremental Sync supported.** This action supports `sync_mode: "incremental"` in the `parameters` object. Requires an [Engagement Identity](/v1/identities/engagement).
* The first iteration performs a **full sync** (limited by `max_results`).
* Each subsequent scheduled iteration automatically returns **only new data** since the last retrieval.
* If the previous run is still in progress when the next iteration triggers, that iteration will be **skipped**.
* See the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode) for details and limitations.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Page Followers
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-page-followers
v1/api/actions.json post /actions/linkedin-extract-page-followers/run/live
Extract the list of followers of a LinkedIn company page. Requires page admin access.
To run this automated action, the connected LinkedIn identity must be the page admin.
Otherwise, it won't work — this is a LinkedIn limitation we cannot work around.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Page Followers Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-page-followers-async
v1/api/actions.json post /actions/linkedin-extract-page-followers/run/async
Extract LinkedIn company page followers asynchronously with automatic pagination. Results are delivered via callback.
To run this automated action, the connected LinkedIn identity must be the page admin.
Otherwise, it won't work — this is a LinkedIn limitation we cannot work around.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Incremental Sync supported.** This action supports `sync_mode: "incremental"` in the `parameters` object. Requires an [Engagement Identity](/v1/identities/engagement).
* The first run performs a **full sync** (limited by `max_results`).
* Subsequent runs via [`POST /v1/runs/{run_uid}/continue`](/v1/api/runs/continue) return **only new data** since the last retrieval.
* See the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode) for details and limitations.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Page Followers Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-page-followers-schedule
v1/api/actions.json post /actions/linkedin-extract-page-followers/run/schedule
Schedule extraction of LinkedIn company page followers at a specific time or on a recurring basis.
To run this automated action, the connected LinkedIn identity must be the page admin.
Otherwise, it won't work — this is a LinkedIn limitation we cannot work around.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Incremental Sync supported.** This action supports `sync_mode: "incremental"` in the `parameters` object. Requires an [Engagement Identity](/v1/identities/engagement).
* The first iteration performs a **full sync** (limited by `max_results`).
* Each subsequent scheduled iteration automatically returns **only new data** since the last retrieval.
* If the previous run is still in progress when the next iteration triggers, that iteration will be **skipped**.
* See the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode) for details and limitations.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Comment Activity
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-comment-activity
v1/api/actions.json post /actions/linkedin-extract-people-comment-activity/run/live
Extract the comment activity history of a LinkedIn profile, showing posts they have commented on.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn People Comment Activity Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-comment-activity-async
v1/api/actions.json post /actions/linkedin-extract-people-comment-activity/run/async
Extract LinkedIn profile comment activity asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Comment Activity Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-comment-activity-schedule
v1/api/actions.json post /actions/linkedin-extract-people-comment-activity/run/schedule
Schedule extraction of LinkedIn profile comment activity at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Post Activity
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-post-activity
v1/api/actions.json post /actions/linkedin-extract-people-post-activity/run/live
Extract the post activity history of a LinkedIn profile, showing content they have published.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
## Understanding Author Fields
The response includes three different author-related fields that help you understand the post structure:
### `activity_author`
The person who **performs the activity** (e.g., the person who reshared, commented, or reacted). For original posts, this is the same as `author`. For reshares, this is the person who shared the content.
### `author`
The author of the **first-level post** (the visible post you see directly). This is the person or company whose post appears in the activity feed.
### `source_post`
Contains information about the **source post** (2nd level) when the visible post is a reshare. This object includes:
* `author`: The author of the source post that was reshared
* `linkedin_post_id`: The source post's ID
* `linkedin_post_url`: The source post's URL
* `content_text`: The source post's content
**Note:** `source_post` returns `null` if there is no 2nd level post (i.e., the visible post is an source post, not a reshare).
### Example Structure
For an **original post**:
* `author` → Author of the post
* `activity_author` → Same as `author` (they created the post)
* `source_post` → `null` (no source post to reference)
For a **reshare without comment**:
* `author` → Author of the reshared post
* `activity_author` → Person who performed the reshare activity
* `source_post.author` → `null` (no source post to reference)
For a **reshare with comment**:
* `author` → Author of the post, same as the activity\_author
* `activity_author` → Person who performed the reshare activity
* `source_post.author` → Author of the reshared post
For a **reshare without comment of a post sharing another post**:
* `author` → Author of the reshared post (first level)
* `activity_author` → Person who performed the reshare
* `source_post.author` → Author of the source post shared by the first level (second level)
# Extract LinkedIn People Post Activity Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-post-activity-async
v1/api/actions.json post /actions/linkedin-extract-people-post-activity/run/async
Extract LinkedIn profile post activity asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Post Activity Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-post-activity-schedule
v1/api/actions.json post /actions/linkedin-extract-people-post-activity/run/schedule
Schedule extraction of LinkedIn profile post activity at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Reaction Activity
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-reaction-activity
v1/api/actions.json post /actions/linkedin-extract-people-reaction-activity/run/live
Extract the reaction activity history of a LinkedIn profile, showing posts they have liked or reacted to.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn People Reaction Activity Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-reaction-activity-async
v1/api/actions.json post /actions/linkedin-extract-people-reaction-activity/run/async
Extract LinkedIn profile reaction activity asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn People Reaction Activity Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-people-reaction-activity-schedule
v1/api/actions.json post /actions/linkedin-extract-people-reaction-activity/run/schedule
Schedule extraction of LinkedIn profile reaction activity at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Post Commenters
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-commenters
v1/api/actions.json post /actions/linkedin-extract-post-commenters/run/live
Extract users who commented on a specific LinkedIn post with their profile information and comments.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Post Commenters Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-commenters-async
v1/api/actions.json post /actions/linkedin-extract-post-commenters/run/async
Extract LinkedIn post commenters asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Post Commenters Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-commenters-schedule
v1/api/actions.json post /actions/linkedin-extract-post-commenters/run/schedule
Schedule extraction of LinkedIn post commenters at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Post Likers
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-likers
v1/api/actions.json post /actions/linkedin-extract-post-likers/run/live
Extract users who liked a specific LinkedIn post. Returns profile information of people who have reacted to the post.
This action allows you to extract users who liked a LinkedIn post.
The public handle (e.g., `john-doe`) is not returned in the response. The `linkedin_profile_url` field contains a different identifier format. If you need the real public profile URL, you'll need to enrich the extracted people using the [Extract LinkedIn People](/v1/api/actions/linkedin-extract-people) action.
## Sorting behavior
The **Most relevant** sorting option intentionally hides part of the data (this is a LinkedIn limitation we cannot control). For example, a post with 1,500 potential likers may only return around 400 results with this sorting.
The **Newest** sorting option may sometimes return incomplete pages, but it will return the complete dataset. For example, all 1,500 likers will be extracted even if some pages have fewer results than expected.
We recommend using the **Newest** sorting option if you need to extract all likers from a post.
### Misc
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Post Likers Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-likers-async
v1/api/actions.json post /actions/linkedin-extract-post-likers/run/async
Extract LinkedIn post likers asynchronously with automatic pagination. Results are delivered via callback.
This action allows you to extract users who liked a LinkedIn post.
The public handle (e.g., `john-doe`) is not returned in the response. The `linkedin_profile_url` field contains a different identifier format. If you need the real public profile URL, you'll need to enrich the extracted people using the [Extract LinkedIn People](/v1/api/actions/linkedin-extract-people) action.
## Sorting behavior
The **Most relevant** sorting option intentionally hides part of the data (this is a LinkedIn limitation we cannot control). For example, a post with 1,500 potential likers may only return around 400 results with this sorting.
The **Newest** sorting option may sometimes return incomplete pages, but it will return the complete dataset. For example, all 1,500 likers will be extracted even if some pages have fewer results than expected.
We recommend using the **Newest** sorting option if you need to extract all likers from a post.
### Misc
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Post Likers Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-likers-schedule
v1/api/actions.json post /actions/linkedin-extract-post-likers/run/schedule
Schedule extraction of LinkedIn post likers at a specific time or on a recurring basis.
This action allows you to extract users who liked a LinkedIn post.
The public handle (e.g., `john-doe`) is not returned in the response. The `linkedin_profile_url` field contains a different identifier format. If you need the real public profile URL, you'll need to enrich the extracted people using the [Extract LinkedIn People](/v1/api/actions/linkedin-extract-people) action.
## Sorting behavior
The **Most relevant** sorting option intentionally hides part of the data (this is a LinkedIn limitation we cannot control). For example, a post with 1,500 potential likers may only return around 400 results with this sorting.
The **Newest** sorting option may sometimes return incomplete pages, but it will return the complete dataset. For example, all 1,500 likers will be extracted even if some pages have fewer results than expected.
We recommend using the **Newest** sorting option if you need to extract all likers from a post.
### Misc
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Post Reposters
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-reposters
v1/api/actions.json post /actions/linkedin-extract-post-reposters/run/live
Extract users who reposted a specific LinkedIn post with their profile information.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract LinkedIn Post Reposters Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-reposters-async
v1/api/actions.json post /actions/linkedin-extract-post-reposters/run/async
Extract LinkedIn post reposters asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Post Reposters Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-post-reposters-schedule
v1/api/actions.json post /actions/linkedin-extract-post-reposters/run/schedule
Schedule extraction of LinkedIn post reposters at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Profile Viewers
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-profile-viewers
v1/api/actions.json post /actions/linkedin-extract-profile-viewers/run/live
Extract the list of people who have viewed your LinkedIn profile recently.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Profile Viewers Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-profile-viewers-async
v1/api/actions.json post /actions/linkedin-extract-profile-viewers/run/async
Extract LinkedIn profile viewers asynchronously with automatic pagination. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Incremental Sync supported.** This action supports `sync_mode: "incremental"` in the `parameters` object. Requires an [Engagement Identity](/v1/identities/engagement).
* The first run performs a **full sync** (limited by `max_results`).
* Subsequent runs via [`POST /v1/runs/{run_uid}/continue`](/v1/api/runs/continue) return **only new data** since the last retrieval.
* See the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode) for details and limitations.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Profile Viewers Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-profile-viewers-schedule
v1/api/actions.json post /actions/linkedin-extract-profile-viewers/run/schedule
Schedule extraction of LinkedIn profile viewers at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Incremental Sync supported.** This action supports `sync_mode: "incremental"` in the `parameters` object. Requires an [Engagement Identity](/v1/identities/engagement).
* The first iteration performs a **full sync** (limited by `max_results`).
* Each subsequent scheduled iteration automatically returns **only new data** since the last retrieval.
* If the previous run is still in progress when the next iteration triggers, that iteration will be **skipped**.
* See the [Incremental Sync guide](/v1/runs/overview#incremental-sync-mode) for details and limitations.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn School Alumnis
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-school-alumnis
v1/api/actions.json post /actions/linkedin-extract-school-alumnis/run/live
Extract the list of alumni from a LinkedIn school page with their profile information.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract LinkedIn School Alumnis Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-school-alumnis-async
v1/api/actions.json post /actions/linkedin-extract-school-alumnis/run/async
Extract LinkedIn school alumni asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn School Alumnis Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-school-alumnis-schedule
v1/api/actions.json post /actions/linkedin-extract-school-alumnis/run/schedule
Schedule extraction of LinkedIn school alumni at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Similar Companies
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-similar-companies
v1/api/actions.json post /actions/linkedin-extract-similar-companies/run/live
Extract a list of companies similar to a given LinkedIn company page, based on LinkedIn's recommendations.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract LinkedIn Similar Companies Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-similar-companies-async
v1/api/actions.json post /actions/linkedin-extract-similar-companies/run/async
Extract similar companies from a LinkedIn company page asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Similar Companies Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-similar-companies-schedule
v1/api/actions.json post /actions/linkedin-extract-similar-companies/run/schedule
Schedule extraction of similar companies from a LinkedIn company page at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Find LinkedIn Company URL
Source: https://docs.edges.run/v1/api/actions/linkedin-find-company-url
v1/api/actions.json post /actions/linkedin-find-company-url/run/live
Use AI to find a LinkedIn company page URL from a company name or domain.
This action uses AI to automatically find LinkedIn company page URLs based on company information. You can provide either a company name or domain, and the action will search and return the corresponding LinkedIn company page URL.
# Find LinkedIn Company URL Async
Source: https://docs.edges.run/v1/api/actions/linkedin-find-company-url-async
v1/api/actions.json post /actions/linkedin-find-company-url/run/async
Use AI to find a LinkedIn company page URL asynchronously. Results are delivered via callback.
This action uses AI to automatically find LinkedIn company page URLs based on company information. You can provide either a company name or domain, and the action will search and return the corresponding LinkedIn company page URL.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Find LinkedIn Company URL Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-find-company-url-schedule
v1/api/actions.json post /actions/linkedin-find-company-url/run/schedule
Schedule AI-powered LinkedIn company URL lookup at a specific time or on a recurring basis.
This action uses AI to automatically find LinkedIn company page URLs based on company information. You can provide either a company name or domain, and the action will search and return the corresponding LinkedIn company page URL.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Find LinkedIn Profile URL
Source: https://docs.edges.run/v1/api/actions/linkedin-find-profile-url
v1/api/actions.json post /actions/linkedin-find-profile-url/run/live
Use AI to find a LinkedIn profile URL from a person's name and optional contextual information.
This action uses AI to automatically find LinkedIn profile URLs for individuals based on their name.
Simply provide a person's name, and the action will search and return their LinkedIn profile URL.
# Find LinkedIn Profile URL Async
Source: https://docs.edges.run/v1/api/actions/linkedin-find-profile-url-async
v1/api/actions.json post /actions/linkedin-find-profile-url/run/async
Use AI to find a LinkedIn profile URL asynchronously. Results are delivered via callback.
This action uses AI to automatically find LinkedIn profile URLs for individuals based on their name.
Simply provide a person's name, and the action will search and return their LinkedIn profile URL.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Find LinkedIn Profile URL Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-find-profile-url-schedule
v1/api/actions.json post /actions/linkedin-find-profile-url/run/schedule
Schedule AI-powered LinkedIn profile URL lookup at a specific time or on a recurring basis.
This action uses AI to automatically find LinkedIn profile URLs for individuals based on their name.
Simply provide a person's name, and the action will search and return their LinkedIn profile URL.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Send LinkedIn InMail
Source: https://docs.edges.run/v1/api/actions/linkedin-inmail-profile
v1/api/actions.json post /actions/linkedin-inmail-profile/run/live
Send an InMail message to a LinkedIn profile, even if you're not connected. Requires LinkedIn Premium.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Video and Audio Format
* Audio files are automatically sent as **voice messages** when using the following formats: `m4a`, `mp3`, `wav`, `flac`
* Video files are automatically sent as **video messages** when using the following formats: `avi`, `mp4`
* **File size limit** remains unchanged: maximum \~27 MB per attachment (based on Base64 payload size).
* Unsupported formats and any attached files continue to be sent as standard file attachments.
# Send LinkedIn InMail Async
Source: https://docs.edges.run/v1/api/actions/linkedin-inmail-profile-async
v1/api/actions.json post /actions/linkedin-inmail-profile/run/async
Send a LinkedIn InMail asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
## Video and Audio Format
* Audio files are automatically sent as **voice messages** when using the following formats: `m4a`, `mp3`, `wav`, `flac`
* Video files are automatically sent as **video messages** when using the following formats: `avi`, `mp4`
* **File size limit** remains unchanged: maximum \~27 MB per attachment (based on Base64 payload size).
* Unsupported formats and any attached files continue to be sent as standard file attachments.
# Send LinkedIn InMail Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-inmail-profile-schedule
v1/api/actions.json post /actions/linkedin-inmail-profile/run/schedule
Schedule sending a LinkedIn InMail at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
## Video and Audio Format
* Audio files are automatically sent as **voice messages** when using the following formats: `m4a`, `mp3`, `wav`, `flac`
* Video files are automatically sent as **video messages** when using the following formats: `avi`, `mp4`
* **File size limit** remains unchanged: maximum \~27 MB per attachment (based on Base64 payload size).
* Unsupported formats and any attached files continue to be sent as standard file attachments.
# Mark LinkedIn Message as Read
Source: https://docs.edges.run/v1/api/actions/linkedin-mark-message-as-read
v1/api/actions.json post /actions/linkedin-mark-message-as-read/run/live
Mark a LinkedIn conversation as read using its thread ID.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Provide a **`linkedin_thread_id`** (or a LinkedIn messaging thread URL). You can retrieve thread IDs from [Extract LinkedIn Conversations](/v1/api/actions/linkedin-extract-conversations) or [Extract LinkedIn Messages](/v1/api/actions/linkedin-extract-messages).
# Mark LinkedIn Message as Read Async
Source: https://docs.edges.run/v1/api/actions/linkedin-mark-message-as-read-async
v1/api/actions.json post /actions/linkedin-mark-message-as-read/run/async
Mark a LinkedIn conversation as read asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Provide a **`linkedin_thread_id`** (or a LinkedIn messaging thread URL). You can retrieve thread IDs from [Extract LinkedIn Conversations](/v1/api/actions/linkedin-extract-conversations) or [Extract LinkedIn Messages](/v1/api/actions/linkedin-extract-messages).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Mark LinkedIn Message as Read Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-mark-message-as-read-schedule
v1/api/actions.json post /actions/linkedin-mark-message-as-read/run/schedule
Schedule marking a LinkedIn conversation as read at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Provide a **`linkedin_thread_id`** (or a LinkedIn messaging thread URL). You can retrieve thread IDs from [Extract LinkedIn Conversations](/v1/api/actions/linkedin-extract-conversations) or [Extract LinkedIn Messages](/v1/api/actions/linkedin-extract-messages).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Message LinkedIn Profile
Source: https://docs.edges.run/v1/api/actions/linkedin-message-profile
v1/api/actions.json post /actions/linkedin-message-profile/run/live
Send a direct message to a LinkedIn connection.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Video and Audio Format
* Audio files are automatically sent as **voice messages** when using the following formats: `m4a`, `mp3`, `wav`, `flac`
* Video files are automatically sent as **video messages** when using the following formats: `avi`, `mp4`
* **File size limit** remains unchanged: maximum \~27 MB per attachment (based on Base64 payload size).
* Unsupported formats and any attached files continue to be sent as standard file attachments.
# Message LinkedIn Profile Async
Source: https://docs.edges.run/v1/api/actions/linkedin-message-profile-async
v1/api/actions.json post /actions/linkedin-message-profile/run/async
Send a direct message to a LinkedIn connection asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
## Video and Audio Format
* Audio files are automatically sent as **voice messages** when using the following formats: `m4a`, `mp3`, `wav`, `flac`
* Video files are automatically sent as **video messages** when using the following formats: `avi`, `mp4`
* **File size limit** remains unchanged: maximum \~27 MB per attachment (based on Base64 payload size).
* Unsupported formats and any attached files continue to be sent as standard file attachments.
# Message LinkedIn Profile Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-message-profile-schedule
v1/api/actions.json post /actions/linkedin-message-profile/run/schedule
Schedule sending a direct message to a LinkedIn connection at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
## Video and Audio Format
* Audio files are automatically sent as **voice messages** when using the following formats: `m4a`, `mp3`, `wav`, `flac`
* Video files are automatically sent as **video messages** when using the following formats: `avi`, `mp4`
* **File size limit** remains unchanged: maximum \~27 MB per attachment (based on Base64 payload size).
* Unsupported formats and any attached files continue to be sent as standard file attachments.
# Search LinkedIn Companies
Source: https://docs.edges.run/v1/api/actions/linkedin-search-companies
v1/api/actions.json post /actions/linkedin-search-companies/run/live
Search for companies on LinkedIn using filters like industry, size, location, and keywords.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Search LinkedIn Companies Async
Source: https://docs.edges.run/v1/api/actions/linkedin-search-companies-async
v1/api/actions.json post /actions/linkedin-search-companies/run/async
Search LinkedIn companies asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Companies Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-search-companies-schedule
v1/api/actions.json post /actions/linkedin-search-companies/run/schedule
Schedule a LinkedIn company search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Company Employees
Source: https://docs.edges.run/v1/api/actions/linkedin-search-company-employees
v1/api/actions.json post /actions/linkedin-search-company-employees/run/live
Search for employees of a specific company on LinkedIn with optional filters.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Search LinkedIn Company Employees Async
Source: https://docs.edges.run/v1/api/actions/linkedin-search-company-employees-async
v1/api/actions.json post /actions/linkedin-search-company-employees/run/async
Search LinkedIn company employees asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Company Employees Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-search-company-employees-schedule
v1/api/actions.json post /actions/linkedin-search-company-employees/run/schedule
Schedule a LinkedIn company employees search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Content
Source: https://docs.edges.run/v1/api/actions/linkedin-search-content
v1/api/actions.json post /actions/linkedin-search-content/run/live
Search for posts and articles on LinkedIn using keywords and filters.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Search LinkedIn Content Async
Source: https://docs.edges.run/v1/api/actions/linkedin-search-content-async
v1/api/actions.json post /actions/linkedin-search-content/run/async
Search LinkedIn content asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Content Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-search-content-schedule
v1/api/actions.json post /actions/linkedin-search-content/run/schedule
Schedule a LinkedIn content search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Events
Source: https://docs.edges.run/v1/api/actions/linkedin-search-events
v1/api/actions.json post /actions/linkedin-search-events/run/live
Search for events on LinkedIn using keywords, date, and location filters.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Search LinkedIn Events Async
Source: https://docs.edges.run/v1/api/actions/linkedin-search-events-async
v1/api/actions.json post /actions/linkedin-search-events/run/async
Search LinkedIn events asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Events Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-search-events-schedule
v1/api/actions.json post /actions/linkedin-search-events/run/schedule
Schedule a LinkedIn events search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Groups
Source: https://docs.edges.run/v1/api/actions/linkedin-search-groups
v1/api/actions.json post /actions/linkedin-search-groups/run/live
Search for groups on LinkedIn using keywords and filters.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Search LinkedIn Groups Async
Source: https://docs.edges.run/v1/api/actions/linkedin-search-groups-async
v1/api/actions.json post /actions/linkedin-search-groups/run/async
Search LinkedIn groups asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Groups Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-search-groups-schedule
v1/api/actions.json post /actions/linkedin-search-groups/run/schedule
Schedule a LinkedIn groups search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Jobs
Source: https://docs.edges.run/v1/api/actions/linkedin-search-jobs
v1/api/actions.json post /actions/linkedin-search-jobs/run/live
Search for job postings on LinkedIn using keywords, location, company, and other filters.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Search LinkedIn Jobs Async
Source: https://docs.edges.run/v1/api/actions/linkedin-search-jobs-async
v1/api/actions.json post /actions/linkedin-search-jobs/run/async
Search LinkedIn jobs asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Jobs Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-search-jobs-schedule
v1/api/actions.json post /actions/linkedin-search-jobs/run/schedule
Schedule a LinkedIn jobs search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn People
Source: https://docs.edges.run/v1/api/actions/linkedin-search-people
v1/api/actions.json post /actions/linkedin-search-people/run/live
Search for people on LinkedIn using filters like title, company, location, and keywords.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
When **`only_extract_unique_profile`** is enabled, the action expects exactly one matching person. If the search returns **more than one result**, the API returns a **404 Not Found** with an error message indicating that multiple profiles were found.
# Search LinkedIn People Async
Source: https://docs.edges.run/v1/api/actions/linkedin-search-people-async
v1/api/actions.json post /actions/linkedin-search-people/run/async
Search LinkedIn people asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
If a monthly LinkedIn limit is reached (`LIMIT_REACHED`), async `linkedin-search-people` runs are **automatically retried** when the limit resets instead of failing permanently.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
When **`only_extract_unique_profile`** is enabled, the action expects exactly one matching person. If the search returns **more than one result**, the API returns a **404 Not Found** with an error message indicating that multiple profiles were found.
# Search LinkedIn People Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-search-people-schedule
v1/api/actions.json post /actions/linkedin-search-people/run/schedule
Schedule a LinkedIn people search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
If a monthly LinkedIn limit is reached (`LIMIT_REACHED`), async `linkedin-search-people` runs are **automatically retried** when the limit resets instead of failing permanently.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
When **`only_extract_unique_profile`** is enabled, the action expects exactly one matching person. If the search returns **more than one result**, the API returns a **404 Not Found** with an error message indicating that multiple profiles were found.
# Search LinkedIn Schools
Source: https://docs.edges.run/v1/api/actions/linkedin-search-schools
v1/api/actions.json post /actions/linkedin-search-schools/run/live
Search for schools and universities on LinkedIn using keywords and filters.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Search LinkedIn Schools Async
Source: https://docs.edges.run/v1/api/actions/linkedin-search-schools-async
v1/api/actions.json post /actions/linkedin-search-schools/run/async
Search LinkedIn schools asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search LinkedIn Schools Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-search-schools-schedule
v1/api/actions.json post /actions/linkedin-search-schools/run/schedule
Schedule a LinkedIn schools search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Visit LinkedIn Profile
Source: https://docs.edges.run/v1/api/actions/linkedin-visit-profile
v1/api/actions.json post /actions/linkedin-visit-profile/run/live
Visit a LinkedIn profile to show up in their "Who viewed your profile" section.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
This Action enables you to visit a LinkedIn profile.
If you want to enrich profile data, use [Extract LinkedIn People](/v1/api/actions/linkedin-extract-people) instead.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Visit LinkedIn Profile Async
Source: https://docs.edges.run/v1/api/actions/linkedin-visit-profile-async
v1/api/actions.json post /actions/linkedin-visit-profile/run/async
Visit a LinkedIn profile asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Accept LinkedIn Received Invitation
Source: https://docs.edges.run/v1/api/actions/linkedin-accept-invitation
v1/api/actions.json post /actions/linkedin-accept-invitation/run/live
Accept one pending LinkedIn connection invitation from other users.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Accept LinkedIn Received Invitations Async
Source: https://docs.edges.run/v1/api/actions/linkedin-accept-invitations-async
v1/api/actions.json post /actions/linkedin-accept-invitations/run/async
Accept all pending LinkedIn connection invitations asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Accept LinkedIn Received Invitations Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-accept-invitations-schedule
v1/api/actions.json post /actions/linkedin-accept-invitations/run/schedule
Schedule acceptance of all pending LinkedIn connection invitations at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Comment LinkedIn Post
Source: https://docs.edges.run/v1/api/actions/linkedin-comment-post
v1/api/actions.json post /actions/linkedin-comment-post/run/live
Post a comment on a LinkedIn post using your account.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Comment LinkedIn Post Async
Source: https://docs.edges.run/v1/api/actions/linkedin-comment-post-async
v1/api/actions.json post /actions/linkedin-comment-post/run/async
Post a comment on a LinkedIn post asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Comment LinkedIn Post Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-comment-post-schedule
v1/api/actions.json post /actions/linkedin-comment-post/run/schedule
Schedule posting a comment on a LinkedIn post at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Received Invitations
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-received-invitations
v1/api/actions.json post /actions/linkedin-extract-received-invitations/run/live
Extract the list of pending connection invitations you have received on LinkedIn.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Received Invitations Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-received-invitations-async
v1/api/actions.json post /actions/linkedin-extract-received-invitations/run/async
Extract LinkedIn received invitations asynchronously with automatic pagination. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Received Invitations Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-received-invitations-schedule
v1/api/actions.json post /actions/linkedin-extract-received-invitations/run/schedule
Schedule extraction of LinkedIn received invitations at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Sent Invitations
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-sent-invitations
v1/api/actions.json post /actions/linkedin-extract-sent-invitations/run/live
Extract the list of pending connection invitations you have sent on LinkedIn.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract LinkedIn Sent Invitations Async
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-sent-invitations-async
v1/api/actions.json post /actions/linkedin-extract-sent-invitations/run/async
Extract LinkedIn sent invitations asynchronously with automatic pagination. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract LinkedIn Sent Invitations Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-extract-sent-invitations-schedule
v1/api/actions.json post /actions/linkedin-extract-sent-invitations/run/schedule
Schedule extraction of LinkedIn sent invitations at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Follow LinkedIn Profile
Source: https://docs.edges.run/v1/api/actions/linkedin-follow-profile
v1/api/actions.json post /actions/linkedin-follow-profile/run/live
Follow a LinkedIn profile to receive their updates in your feed without connecting.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Follow LinkedIn Profile Async
Source: https://docs.edges.run/v1/api/actions/linkedin-follow-profile-async
v1/api/actions.json post /actions/linkedin-follow-profile/run/async
Follow a LinkedIn profile asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Follow LinkedIn Profile Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-follow-profile-schedule
v1/api/actions.json post /actions/linkedin-follow-profile/run/schedule
Schedule following a LinkedIn profile at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Invite People to LinkedIn Event
Source: https://docs.edges.run/v1/api/actions/linkedin-invite-event
v1/api/actions.json post /actions/linkedin-invite-event/run/live
Send event invitations to LinkedIn profiles for events you organize.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Invite People to LinkedIn Event Async
Source: https://docs.edges.run/v1/api/actions/linkedin-invite-event-async
v1/api/actions.json post /actions/linkedin-invite-event/run/async
Send LinkedIn event invitations asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Invite People to LinkedIn Event Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-invite-event-schedule
v1/api/actions.json post /actions/linkedin-invite-event/run/schedule
Schedule sending LinkedIn event invitations at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Like LinkedIn Post
Source: https://docs.edges.run/v1/api/actions/linkedin-like-post
v1/api/actions.json post /actions/linkedin-like-post/run/live
Like or react to a LinkedIn post using your account.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Like LinkedIn Post Async
Source: https://docs.edges.run/v1/api/actions/linkedin-like-post-async
v1/api/actions.json post /actions/linkedin-like-post/run/async
Like a LinkedIn post asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Like LinkedIn Post Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-like-post-schedule
v1/api/actions.json post /actions/linkedin-like-post/run/schedule
Schedule liking a LinkedIn post at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Visit LinkedIn Company
Source: https://docs.edges.run/v1/api/actions/linkedin-visit-company
v1/api/actions.json post /actions/linkedin-visit-company/run/live
Visit a LinkedIn company page to generate an impression and gather page view data.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Visit LinkedIn Company Async
Source: https://docs.edges.run/v1/api/actions/linkedin-visit-company-async
v1/api/actions.json post /actions/linkedin-visit-company/run/async
Visit a LinkedIn company page asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Visit LinkedIn Company Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-visit-company-schedule
v1/api/actions.json post /actions/linkedin-visit-company/run/schedule
Schedule visiting a LinkedIn company page at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Visit LinkedIn Profile Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-visit-profile-schedule
v1/api/actions.json post /actions/linkedin-visit-profile/run/schedule
Schedule visiting a LinkedIn profile at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Withdraw LinkedIn Pending Invitation
Source: https://docs.edges.run/v1/api/actions/linkedin-withdraw-invitation
v1/api/actions.json post /actions/linkedin-withdraw-invitation/run/live
Withdraw one pending connection invitation you have sent on LinkedIn.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Withdraw LinkedIn Pending Invitations Async
Source: https://docs.edges.run/v1/api/actions/linkedin-withdraw-invitations-async
v1/api/actions.json post /actions/linkedin-withdraw-invitations/run/async
Withdraw all LinkedIn pending invitations asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Withdraw LinkedIn Pending Invitations Schedule
Source: https://docs.edges.run/v1/api/actions/linkedin-withdraw-invitations-schedule
v1/api/actions.json post /actions/linkedin-withdraw-invitations/run/schedule
Schedule withdrawing all LinkedIn pending invitations at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search Recruiter Lite People
Source: https://docs.edges.run/v1/api/actions/recruiterlite-search-people
v1/api/actions.json post /actions/recruiterlite-search-people/run/live
Search for candidates using LinkedIn Recruiter Lite with advanced filters for skills, experience, and location.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Search Recruiter Lite People Async
Source: https://docs.edges.run/v1/api/actions/recruiterlite-search-people-async
v1/api/actions.json post /actions/recruiterlite-search-people/run/async
Search Recruiter Lite for candidates asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search Recruiter Lite People Schedule
Source: https://docs.edges.run/v1/api/actions/recruiterlite-search-people-schedule
v1/api/actions.json post /actions/recruiterlite-search-people/run/schedule
Schedule a Recruiter Lite candidate search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Connect Sales Navigator Profile
Source: https://docs.edges.run/v1/api/actions/salesnavigator-connect-profile
v1/api/actions.json post /actions/salesnavigator-connect-profile/run/live
Send a connection request to a lead from Sales Navigator with an optional personalized message.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Connect Sales Navigator Profile Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-connect-profile-async
v1/api/actions.json post /actions/salesnavigator-connect-profile/run/async
Send a Sales Navigator connection request asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Connect Sales Navigator Profile Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-connect-profile-schedule
v1/api/actions.json post /actions/salesnavigator-connect-profile/run/schedule
Schedule sending a Sales Navigator connection request at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Accounts List
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-accounts-list
v1/api/actions.json post /actions/salesnavigator-extract-accounts-list/run/live
Extract accounts (companies) from a saved accounts list in Sales Navigator.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract Sales Navigator Accounts List Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-accounts-list-async
v1/api/actions.json post /actions/salesnavigator-extract-accounts-list/run/async
Extract Sales Navigator accounts list asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Accounts List Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-accounts-list-schedule
v1/api/actions.json post /actions/salesnavigator-extract-accounts-list/run/schedule
Schedule extraction of Sales Navigator accounts list at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Company
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-company
v1/api/actions.json post /actions/salesnavigator-extract-company/run/live
Extract full company data from a Sales Navigator company page, including revenue, description, employee counts, and other profile metadata.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
The output field `profile_image_url` is **deprecated** and may be removed in a future release. Do not rely on it for new integrations.
# Extract Sales Navigator Company Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-company-async
v1/api/actions.json post /actions/salesnavigator-extract-company/run/async
Extract Sales Navigator company data asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
The output field `profile_image_url` is **deprecated** and may be removed in a future release. Do not rely on it for new integrations.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Company Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-company-schedule
v1/api/actions.json post /actions/salesnavigator-extract-company/run/schedule
Schedule extracting Sales Navigator company data at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
The output field `profile_image_url` is **deprecated** and may be removed in a future release. Do not rely on it for new integrations.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Conversations
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-conversations
v1/api/actions.json post /actions/salesnavigator-extract-conversations/run/live
Extract your Sales Navigator conversations list, including participants, last message metadata, and acceptance status.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract Sales Navigator Conversations (Async)
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-conversations-async
v1/api/actions.json post /actions/salesnavigator-extract-conversations/run/async
Extract your Sales Navigator conversations list asynchronously with callbacks.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract Sales Navigator Conversations (Schedule)
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-conversations-schedule
v1/api/actions.json post /actions/salesnavigator-extract-conversations/run/schedule
Schedule extraction of your Sales Navigator conversations list (cron/one-shot) with callbacks.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract Sales Navigator Company Employee Count
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-employees-count
v1/api/actions.json post /actions/salesnavigator-extract-employees-count/run/live
Extract employee count statistics from a company's Sales Navigator account page.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract Sales Navigator Company Employee Count Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-employees-count-async
v1/api/actions.json post /actions/salesnavigator-extract-employees-count/run/async
Extract Sales Navigator employee count asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Company Employee Count Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-employees-count-schedule
v1/api/actions.json post /actions/salesnavigator-extract-employees-count/run/schedule
Schedule extraction of Sales Navigator employee count at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Employees Distribution
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-employees-distribution
v1/api/actions.json post /actions/salesnavigator-extract-employees-distribution/run/live
Extract employee distribution data (by department, seniority, location) from a Sales Navigator company page.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract Sales Navigator Employees Distribution Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-employees-distribution-async
v1/api/actions.json post /actions/salesnavigator-extract-employees-distribution/run/async
Extract Sales Navigator employees distribution asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Employees Distribution Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-employees-distribution-schedule
v1/api/actions.json post /actions/salesnavigator-extract-employees-distribution/run/schedule
Schedule extraction of Sales Navigator employees distribution at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Leads List
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-leads-list
v1/api/actions.json post /actions/salesnavigator-extract-leads-list/run/live
Extract leads from a saved leads list in Sales Navigator.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Extract Sales Navigator Leads List Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-leads-list-async
v1/api/actions.json post /actions/salesnavigator-extract-leads-list/run/async
Extract Sales Navigator leads list asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Leads List Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-leads-list-schedule
v1/api/actions.json post /actions/salesnavigator-extract-leads-list/run/schedule
Schedule extraction of Sales Navigator leads list at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Extract Sales Navigator Messages
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-messages
v1/api/actions.json post /actions/salesnavigator-extract-messages/run/live
Extract messages from a Sales Navigator thread URL, including message metadata, sender identity, attachments, and message type.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract Sales Navigator Messages (Async)
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-messages-async
v1/api/actions.json post /actions/salesnavigator-extract-messages/run/async
Extract Sales Navigator thread messages asynchronously with callbacks.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Extract Sales Navigator Messages (Schedule)
Source: https://docs.edges.run/v1/api/actions/salesnavigator-extract-messages-schedule
v1/api/actions.json post /actions/salesnavigator-extract-messages/run/schedule
Schedule extraction of Sales Navigator thread messages (cron/one-shot) with callbacks.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Send Sales Navigator InMail
Source: https://docs.edges.run/v1/api/actions/salesnavigator-inmail-profile
v1/api/actions.json post /actions/salesnavigator-inmail-profile/run/live
Send an InMail message to a lead via Sales Navigator.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Reliability & error handling
When sending an InMail, Edges may detect that the target user has **blocked** the sender.
In that case, we perform an additional check to determine whether you still have InMail credits:
* If credits **remain**, the API returns **`SN_INMAIL_UNREACHABLE_USER`**
* If credits are **exhausted**, the API returns **`LK_INMAIL_NOT_ENOUGH_CREDIT`**
**Edge case:** if you have **0 credits** and the target user blocked you, the returned error will be `LK_INMAIL_NOT_ENOUGH_CREDIT`.
# Send Sales Navigator InMail Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-inmail-profile-async
v1/api/actions.json post /actions/salesnavigator-inmail-profile/run/async
Send a Sales Navigator InMail asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Reliability & error handling
When sending an InMail, Edges may detect that the target user has **blocked** the sender.
In that case, we perform an additional check to determine whether you still have InMail credits:
* If credits **remain**, the API returns **`SN_INMAIL_UNREACHABLE_USER`**
* If credits are **exhausted**, the API returns **`LK_INMAIL_NOT_ENOUGH_CREDIT`**
**Edge case:** if you have **0 credits** and the target user blocked you, the returned error will be `LK_INMAIL_NOT_ENOUGH_CREDIT`.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Send Sales Navigator InMail Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-inmail-profile-schedule
v1/api/actions.json post /actions/salesnavigator-inmail-profile/run/schedule
Schedule sending a Sales Navigator InMail at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
## Reliability & error handling
When sending an InMail, Edges may detect that the target user has **blocked** the sender.
In that case, we perform an additional check to determine whether you still have InMail credits:
* If credits **remain**, the API returns **`SN_INMAIL_UNREACHABLE_USER`**
* If credits are **exhausted**, the API returns **`LK_INMAIL_NOT_ENOUGH_CREDIT`**
**Edge case:** if you have **0 credits** and the target user blocked you, the returned error will be `LK_INMAIL_NOT_ENOUGH_CREDIT`.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search Sales Navigator Companies
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-companies
v1/api/actions.json post /actions/salesnavigator-search-companies/run/live
Search for accounts (companies) on Sales Navigator using advanced filters.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
If you are looking for the "saved search" version of this action, use the **[Saved Search Sales Navigator Companies](/v1/api/actions/salesnavigator-search-saved-companies)** endpoint instead.
# Search Sales Navigator Companies Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-companies-async
v1/api/actions.json post /actions/salesnavigator-search-companies/run/async
Search Sales Navigator companies asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
If you are looking for the "saved search" version of this action, use the **[Saved Search Sales Navigator Companies Async](/v1/api/actions/salesnavigator-search-saved-companies-async)** endpoint instead.
# Search Sales Navigator Companies Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-companies-schedule
v1/api/actions.json post /actions/salesnavigator-search-companies/run/schedule
Schedule a Sales Navigator companies search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
If you are looking for the "saved search" version of this action, use the **[Saved Search Sales Navigator Companies Schedule](/v1/api/actions/salesnavigator-search-saved-companies-schedule)** endpoint instead.
# Search Sales Navigator Company Employees
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-company-employees
v1/api/actions.json post /actions/salesnavigator-search-company-employees/run/live
Search for leads within a specific company using Sales Navigator filters.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
## Inputs
* `sales_navigator_company_url` **or** `linkedin_company_id`— Identifies the company whose employees you want to search.
* `sales_navigator_profile_search_url`(optional) is a Sales Navigator **people search** URL (`https://www.linkedin.com/sales/search/people...`) to **reuse an existing search**. When provided, the action applies the filters (and optionally `keywords`) from that URL to the company’s employees.
## Reusing a People Search
When you pass **`sales_navigator_profile_search_url`**:
1. The action force the **current\_company** filter in the request with the company id.
2. It **merges** the `query=` from your people search URL with the base query.
3. **Keywords** from the people search are **kept or added** if not already in the base query.
**When to use `sales_navigator_profile_search_url`:** If you provide this URL, the action **relies mainly on the filters from that URL**. Use it to reuse a saved or existing people search and apply it to the company’s employees.
## Notes
* Maximum results : up to 2,500 results.
* Various filters are supported, including **exclusion** fields (e.g. `function_excluded`, `geography_excluded`, `current_job_title_excluded`) and exclusion booleans (`exclude_saved_leads`, `exclude_viewed_leads`, etc.). See the API schema for the full list.
# Search Sales Navigator Company Employees Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-company-employees-async
v1/api/actions.json post /actions/salesnavigator-search-company-employees/run/async
Search Sales Navigator company employees asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
## Inputs
* `sales_navigator_company_url` **or** `linkedin_company_id`— Identifies the company whose employees you want to search.
* `sales_navigator_profile_search_url`(optional) is a Sales Navigator **people search** URL (`https://www.linkedin.com/sales/search/people...`) to **reuse an existing search**. When provided, the action applies the filters (and optionally `keywords`) from that URL to the company’s employees.
## Reusing a People Search
When you pass **`sales_navigator_profile_search_url`**:
1. The action force the **current\_company** filter in the request with the company id.
2. It **merges** the `query=` from your people search URL with the base query.
3. **Keywords** from the people search are **kept or added** if not already in the base query.
**When to use `sales_navigator_profile_search_url`:** If you provide this URL, the action **relies mainly on the filters from that URL**. Use it to reuse a saved or existing people search and apply it to the company’s employees.
## Notes
* Maximum results : up to 2,500 results.
* Various filters are supported, including **exclusion** fields (e.g. `function_excluded`, `geography_excluded`, `current_job_title_excluded`) and exclusion booleans (`exclude_saved_leads`, `exclude_viewed_leads`, etc.). See the API schema for the full list.
# Search Sales Navigator Company Employees Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-company-employees-schedule
v1/api/actions.json post /actions/salesnavigator-search-company-employees/run/schedule
Schedule a Sales Navigator company employees search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
## Inputs
* `sales_navigator_company_url` **or** `linkedin_company_id`— Identifies the company whose employees you want to search.
* `sales_navigator_profile_search_url`(optional) is a Sales Navigator **people search** URL (`https://www.linkedin.com/sales/search/people...`) to **reuse an existing search**. When provided, the action applies the filters (and optionally `keywords`) from that URL to the company’s employees.
## Reusing a People Search
When you pass **`sales_navigator_profile_search_url`**:
1. The action force the **current\_company** filter in the request with the company id.
2. It **merges** the `query=` from your people search URL with the base query.
3. **Keywords** from the people search are **kept or added** if not already in the base query.
**When to use `sales_navigator_profile_search_url`:** If you provide this URL, the action **relies mainly on the filters from that URL**. Use it to reuse a saved or existing people search and apply it to the company’s employees.
## Notes
* Maximum results : up to 2,500 results.
* Various filters are supported, including **exclusion** fields (e.g. `function_excluded`, `geography_excluded`, `current_job_title_excluded`) and exclusion booleans (`exclude_saved_leads`, `exclude_viewed_leads`, etc.). See the API schema for the full list.
# Search Sales Navigator Company Metrics
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-company-metrics
v1/api/actions.json post /actions/salesnavigator-search-company-metrics/run/live
Get total result count metrics for a Sales Navigator company search URL.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Provide a **Sales Navigator company search URL** in `input.sales_navigator_company_search_url` (must start with `https://www.linkedin.com/sales/search/company`).
The response includes **`total_results`**: the number of companies matching the search.
* If **`total_results`** is `0`, the search returns no companies.
* Use this before running a full [company search](/v1/api/actions/salesnavigator-search-companies) or extraction workflow to validate volume.
# Search Sales Navigator Company Metrics Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-company-metrics-async
v1/api/actions.json post /actions/salesnavigator-search-company-metrics/run/async
Get Sales Navigator company search metrics asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Provide a **Sales Navigator company search URL** in `input.sales_navigator_company_search_url`.
The output includes **`total_results`** for the search. If it is `0`, there are no matching companies. See the [live](/v1/api/actions/salesnavigator-search-company-metrics) action page for context.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search Sales Navigator Company Metrics Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-company-metrics-schedule
v1/api/actions.json post /actions/salesnavigator-search-company-metrics/run/schedule
Schedule retrieval of Sales Navigator company search metrics at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Provide a **Sales Navigator company search URL** in `input.sales_navigator_company_search_url`.
The output includes **`total_results`**. See the [live](/v1/api/actions/salesnavigator-search-company-metrics) action page for details.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search Sales Navigator Metrics
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-metrics
v1/api/actions.json post /actions/salesnavigator-search-metrics/run/live
Get metrics and statistics for a Sales Navigator search query, including total results count.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
The response contains a `total_leads` property indicating the total number of results for the search query.
* If `total_leads` equals `0`, the search does not return any results
* Use this property to verify if a search query returns data before running a full search
# Search Sales Navigator Metrics Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-metrics-async
v1/api/actions.json post /actions/salesnavigator-search-metrics/run/async
Get Sales Navigator search metrics asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
The response contains a `total_leads` property indicating the total number of results for the search query.
* If `total_leads` equals `0`, the search does not return any results
* Use this property to verify if a search query returns data before running a full search
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search Sales Navigator Metrics Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-metrics-schedule
v1/api/actions.json post /actions/salesnavigator-search-metrics/run/schedule
Schedule retrieval of Sales Navigator search metrics at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
The response contains a `total_leads` property indicating the total number of results for the search query.
* If `total_leads` equals `0`, the search does not return any results
* Use this property to verify if a search query returns data before running a full search
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Search Sales Navigator People
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-people
v1/api/actions.json post /actions/salesnavigator-search-people/run/live
Search for leads on Sales Navigator using advanced filters like title, company, geography, and more.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
If you are looking for the "saved search" version of this action, use the **[Saved Search Sales Navigator People](/v1/api/actions/salesnavigator-search-saved-people)** endpoint instead.
# Search Sales Navigator People Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-people-async
v1/api/actions.json post /actions/salesnavigator-search-people/run/async
Search Sales Navigator for leads asynchronously with automatic pagination. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
If you are looking for the "saved search" version of this action, use the **[Saved Search Sales Navigator People Async](/v1/api/actions/salesnavigator-search-saved-people-async)** endpoint instead.
# Search Sales Navigator People Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-people-schedule
v1/api/actions.json post /actions/salesnavigator-search-people/run/schedule
Schedule a Sales Navigator leads search at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
If you are looking for the "saved search" version of this action, use the **[Saved Search Sales Navigator People Schedule](/v1/api/actions/salesnavigator-search-saved-people-schedule)** endpoint instead.
# Saved Search Sales Navigator Companies
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-saved-companies
v1/api/actions.json post /actions/salesnavigator-search-saved-companies/run/live
Execute a saved accounts search in Sales Navigator to get current results.
Sales Navigator allows users to save searches for people and companies they are interested in. These saved searches are specific to each LinkedIn account and can be reused for future searches.
More on this in the [LinkedIn help center](https://www.linkedin.com/help/sales-navigator/answer/a102024).
If your Sales Navigator search url contains a `savedSearchId` parameter, it indicates that the search is a saved search.
Note that these actions do not use the common search limits, which may allow you to perform more calls.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Saved Search Sales Navigator Companies Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-saved-companies-async
v1/api/actions.json post /actions/salesnavigator-search-saved-companies/run/async
Execute a saved accounts search asynchronously with automatic pagination. Results are delivered via callback.
Sales Navigator allows users to save searches for people and companies they are interested in. These saved searches are specific to each LinkedIn account and can be reused for future searches.
More on this in the [LinkedIn help center](https://www.linkedin.com/help/sales-navigator/answer/a102024).
If your Sales Navigator search url contains a `savedSearchId` parameter, it indicates that the search is a saved search.
Note that these actions do not use the common search limits, which may allow you to perform more calls.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Saved Search Sales Navigator Companies Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-saved-companies-schedule
v1/api/actions.json post /actions/salesnavigator-search-saved-companies/run/schedule
Schedule execution of a saved accounts search at a specific time or on a recurring basis.
Sales Navigator allows users to save searches for people and companies they are interested in. These saved searches are specific to each LinkedIn account and can be reused for future searches.
More on this in the [LinkedIn help center](https://www.linkedin.com/help/sales-navigator/answer/a102024).
If your Sales Navigator search url contains a `savedSearchId` parameter, it indicates that the search is a saved search.
Note that these actions do not use the common search limits, which may allow you to perform more calls.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Saved Search Sales Navigator People
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-saved-people
v1/api/actions.json post /actions/salesnavigator-search-saved-people/run/live
Execute a saved leads search in Sales Navigator to get current results.
Sales Navigator allows users to save searches for people and companies they are interested in. These saved searches are specific to each LinkedIn account and can be reused for future searches.
More on this in the [LinkedIn help center](https://www.linkedin.com/help/sales-navigator/answer/a102024).
If your Sales Navigator search url contains a `savedSearchId` parameter, it indicates that the search is a saved search.
Note that these actions do not use the common search limits, which may allow you to perform more calls.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
`X-Pagination-Next` and `X-Pagination-Previous` headers may be included in
the response to provide full URLs for the next or previous pages. When
present, always prefer using these headers over manually constructing
pagination URLs.
# Saved Search Sales Navigator People Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-saved-people-async
v1/api/actions.json post /actions/salesnavigator-search-saved-people/run/async
Execute a saved leads search asynchronously with automatic pagination. Results are delivered via callback.
Sales Navigator allows users to save searches for people and companies they are interested in. These saved searches are specific to each LinkedIn account and can be reused for future searches.
More on this in the [LinkedIn help center](https://www.linkedin.com/help/sales-navigator/answer/a102024).
If your Sales Navigator search url contains a `savedSearchId` parameter, it indicates that the search is a saved search.
Note that these actions do not use the common search limits, which may allow you to perform more calls.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Saved Search Sales Navigator People Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-search-saved-people-schedule
v1/api/actions.json post /actions/salesnavigator-search-saved-people/run/schedule
Schedule execution of a saved leads search at a specific time or on a recurring basis.
Sales Navigator allows users to save searches for people and companies they are interested in. These saved searches are specific to each LinkedIn account and can be reused for future searches.
More on this in the [LinkedIn help center](https://www.linkedin.com/help/sales-navigator/answer/a102024).
If your Sales Navigator search url contains a `savedSearchId` parameter, it indicates that the search is a saved search.
Note that these actions do not use the common search limits, which may allow you to perform more calls.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
Async action calls automatically handle pagination through the `X-AUTO-PAGINATE` header, iterating over all pages of results and sending batches to your callback URL.
You can limit the total number of results with the `parameters.max_results` param (see "Body" section).
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Visit Sales Navigator Company
Source: https://docs.edges.run/v1/api/actions/salesnavigator-visit-company
v1/api/actions.json post /actions/salesnavigator-visit-company/run/live
Visit a company's Sales Navigator account page.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Visit Sales Navigator Company Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-visit-company-async
v1/api/actions.json post /actions/salesnavigator-visit-company/run/async
Visit a Sales Navigator account page asynchronously. Results are delivered via callback.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Visit Sales Navigator Company Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-visit-company-schedule
v1/api/actions.json post /actions/salesnavigator-visit-company/run/schedule
Schedule visiting a Sales Navigator account page at a specific time or on a recurring basis.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Visit Sales Navigator Profile
Source: https://docs.edges.run/v1/api/actions/salesnavigator-visit-profile
v1/api/actions.json post /actions/salesnavigator-visit-profile/run/live
Visit a lead's Sales Navigator profile page to show up as a viewer.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
# Visit Sales Navigator Profile Async
Source: https://docs.edges.run/v1/api/actions/salesnavigator-visit-profile-async
v1/api/actions.json post /actions/salesnavigator-visit-profile/run/async
Visit a Sales Navigator lead profile asynchronously. Results are delivered via callback.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Visit Sales Navigator Profile Schedule
Source: https://docs.edges.run/v1/api/actions/salesnavigator-visit-profile-schedule
v1/api/actions.json post /actions/salesnavigator-visit-profile/run/schedule
Schedule visiting a Sales Navigator lead profile at a specific time or on a recurring basis.
No credits required when executed with an Engagement Identity. Set type: "engagement" when creating an Identity via API.
To run LinkedIn actions, you must first create an identity and connect a LinkedIn
account, either using our [Chrome
Extension](https://chromewebstore.google.com/detail/edges-labs/bippgnolleoecnhaninlfmdapbakklpf),
[username/password login](/v1/api/linkedin/authentication), or [Managed
Accounts](/v1/identities/sync-vs-managed) for a hassle-free setup.
**Callback Delivery**: Both `async` and `schedule` modes deliver results via the callback URL provided in your request.
**Consistent Format**: All execution modes use the same action logic, so inputs and results are identical regardless of mode.
**Error Handling**: Errors follow the [standard API error format](/v1/faq-troubleshooting#troubleshooting-errors).
Using `async` and `schedule` modes, you have to implement some kind of callback management. Be sure to check the [Managing Callbacks](/v1/runs/callbacks) guide to better understand how it works and what your can do.
# Product Updates
Source: https://docs.edges.run/v1/changelog/overview
New updates and improvements!
### Improvements
* **Extract LinkedIn People** (`linkedin-extract-people`) — Experience `date` fields now return employment date ranges only. `profile_country` is inferred from recent experience locations when LinkedIn does not expose it directly (remote/hybrid locations excluded). [Extract LinkedIn People](/v1/api/actions/linkedin-extract-people)
* **Extract LinkedIn People Experiences** (`linkedin-extract-people-experiences`) — Fixed `title` and `company_name` mapping; tenure values are no longer placed in `company_name`. [Extract LinkedIn People Experiences](/v1/api/actions/linkedin-extract-people-experiences)
* **LinkedIn Search People** (`linkedin-search-people`) — Async runs that hit a monthly LinkedIn limit (`LIMIT_REACHED`) are now automatically retried when the limit resets instead of failing permanently. [Search LinkedIn People Async](/v1/api/actions/linkedin-search-people-async)
* **Async & schedule runs** — Maximum automatic retries increased from 5 to 10 (up to 11 attempts per run including the initial attempt). [Execution Modes](/v1/runs/overview#async-mode)
### API
* **`NO_DATA_AVAILABLE`** — New error label returned when no data is found for an input (`No data was found for this input.`). [Error Reference](/v1/error-reference)
* **Extract Sales Navigator Company** (`salesnavigator-extract-company`) — Output field `profile_image_url` is deprecated. [Extract Sales Navigator Company](/v1/api/actions/salesnavigator-extract-company)
### Documentation
* **Identity rate limits** — Updated default identity-wide caps: 50/min, 500/15m, 2,500/4h, 15,000/24h. [LinkedIn Smart Limits](/v1/linkedin/limits)
* **Rate limits** — Documented monthly `LIMIT_REACHED` auto-retry for async people search. [Rate Limits](/v1/runs/rate-limits)
* **Extract LinkedIn People** — Documented `profile_country` inference and experience `date` field behavior. [Extract LinkedIn People](/v1/api/actions/linkedin-extract-people)
* **Extract LinkedIn People Experiences** — Documented `title` / `company_name` field mapping. [Extract LinkedIn People Experiences](/v1/api/actions/linkedin-extract-people-experiences)
### API
* **Extract LinkedIn People** (`linkedin-extract-people`) — Profile enrichments quota restored to full capacity: **10,000 / 24 h** (`LK_PROFILE_ENRICHMENTS`). Most previously unavailable fields are back; three output fields remain missing or `null`: `birth_date`, `linkedin_thread_id`, and `connected_at`. [Extract LinkedIn People](/v1/api/actions/linkedin-extract-people)
### Documentation
* **Extract LinkedIn People** — Updated unavailable-fields notice and limits reference to reflect restored capacity and the three remaining gaps. [LinkedIn Smart Limits](/v1/linkedin/limits)
### API
* **Mark LinkedIn Message as Read** — New action `linkedin-mark-message-as-read` (live/async/schedule). Mark a conversation as read using its `linkedin_thread_id`. Requires an [Engagement Identity](/v1/identities/engagement). [Mark LinkedIn Message as Read](/v1/api/actions/linkedin-mark-message-as-read)
### API
* **Extract LinkedIn Page Followers** (`linkedin-extract-page-followers`) — Incremental sync (`sync_mode: "incremental"`) is now supported in async and schedule modes. Fetch only new followers since the last run. Requires an [Engagement Identity](/v1/identities/engagement). [Extract LinkedIn Page Followers](/v1/api/actions/linkedin-extract-page-followers)
### API
* **Sales Navigator InMail Profile** — Improved error handling when a target user blocks us: we now check remaining InMail credits and return proper errors.
* **Sales Navigator ID ↔ LinkedIn handle mapping** — New actions [`linkedin-extract-salesnavigator-profile-id`](/v1/api/actions/linkedin-extract-salesnavigator-profile-id) (handle/URL → SN ID) and [`linkedin-extract-linkedin-profile-handle`](/v1/api/actions/linkedin-extract-linkedin-profile-handle) (SN ID/URL → handle).
### Improvements
* **Extract LinkedIn People** (`linkedin-extract-people`) — Added `number_share_connections` to the output for visibility into mutual connections. [Extract LinkedIn People](/v1/api/actions/linkedin-extract-people)
* **Extract LinkedIn People Experiences** (`linkedin-extract-people-experiences`) — Improved handling of `job_time_period` values that do not include a month. [Extract LinkedIn People Experiences](/v1/api/actions/linkedin-extract-people-experiences)
* **Extract LinkedIn Event Attendees** (`linkedin-extract-event-attendees`) — Fixed data handling for private/blocked profiles with consistent nullability and safe access. The number of results returned may differ from the count shown on LinkedIn when some attendees have private profile settings. [Extract LinkedIn Event Attendees](/v1/api/actions/linkedin-extract-event-attendees)
### Documentation
* **Only extract unique profile** — Clarified the `only_extract_unique_profile` behavior in docs.
* **Sales Navigator schema differences** — Documented fields temporarily unavailable when data is sourced from Sales Navigator on `linkedin-extract-people` and `linkedin-extract-company`.
* **New identity ramp-up** — Documented 5-day and first-day hourly capacity ramp-up for newly connected identities. [LinkedIn Smart Limits](/v1/linkedin/limits#new-identity-ramp-up)
### Platform
* **LinkedIn cookies lifecycle** — Persist additional cookies on refresh and login to improve session stability and stealth.
* **LinkedIn Search Generic** — Improved `linkedin_profile_id` handling and validation to reduce malformed or ambiguous IDs.
### Documentation
* **LinkedIn Smart Limits** — Quotas and per-minute caps in the limits reference are aligned with `IntAccLimits` (24 h and \~31 d windows). Added default rate caps when an action omits them (5/s, 30/min, 300/15 min, 1,200/4 h, 7,000/24 h), plus limits for profile components, saved searches, posts, activity extracts, and InMail. [LinkedIn Smart Limits](/v1/linkedin/limits)
### API
* **Extract Sales Navigator Messages** — New action `salesnavigator-extract-messages` (live/async/schedule). [Extract Sales Navigator Messages](/v1/api/actions/salesnavigator-extract-messages)
* **Extract Sales Navigator Conversations** — New action `salesnavigator-extract-conversations` (live/async/schedule). [Extract Sales Navigator InMail Conversations](/v1/api/actions/salesnavigator-extract-conversations)
### Correction
* **Uniform `linkedin_profile_url` format** — `linkedin_profile_url` values no longer include `miniProfileUrn` query parameters, so the same canonical URL shape is used consistently across Edges endpoints.
* **Current company in header** — On [`linkedin-extract-people`](/v1/api/actions/linkedin-extract-people), `company_name` now matches the company name shown in the profile **header** when the **`highlights`** parameter is enabled.
### Improvements & Fixes
* **LinkedIn protections** — Stricter **per-action** limits, broader **async** safeguards, and **higher minimum delays** on sensitive extractors to cut throttling risk and better protect identities.
* **Extract LinkedIn People** (`linkedin-extract-people`) — Fixed profile **country** resolution. [Extract LinkedIn People](/v1/api/actions/linkedin-extract-people)
* **Extract LinkedIn Company Viewers** — Fixed **missing profile pictures** in viewer results. [Extract LinkedIn Company Viewers](/v1/api/actions/linkedin-extract-company-viewers)
### API
* **Search Sales Navigator Company Metrics** — New action `salesnavigator-search-company-metrics`: total-count metrics for a Sales Navigator **company** search, with its own request/response schema.
* **Search Sales Navigator People Metrics (rename)** — `salesnavigator-search-metrics` is renamed to `salesnavigator-search-people-metrics`.
* **Backward compatibility** — `salesnavigator-search-metrics` remains accepted as an alias; existing callers are not broken.
### App
* **Search identities by UID** — You can search for identities by their **UID** in the [Identities](https://app.edges.run/identities) page in the dashboard.
### Improvements
* **LinkedIn outreach (async only)** — `linkedin-inmail-profile`, `linkedin-message-profile`, `linkedin-visit-profile`, `linkedin-connect-profile`, and `salesnavigator-inmail-profile` now have stricter pacing in **async** : big volume will take a little bit longer as usual; **live mode is unchanged** : you still have to space your call yourself.
* **LinkedIn checkpoint / CAPTCHA** — Fewer automatic attempts to solve captcha during identity login checkpoints (reduces **524** timeouts). If resolution still does not complete in time, responses may return a **`CAPTCHA`** checkpoint; poll [`POST /v1/identities/{identity_uid}/integrations/linkedin/checkpoint`](/v1/api/linkedin/checkpoint) with `{}` until it clears, then handle any next checkpoint per [Resolve LinkedIn Checkpoint](/v1/api/linkedin/checkpoint).
### Documentation
* **Resolve LinkedIn Checkpoint** — Documented **CAPTCHA after maximum attempts**, reduced captcha attempt limit (**524** mitigation), polling with `{}`, and follow-on checkpoints. [Checkpoint API](/v1/api/linkedin/checkpoint)
### API
* **Incremental Sync Mode** — New `sync_mode` parameter (`full` or `incremental`) for async and scheduled runs. Fetch only new data since the last retrieval instead of the full dataset. Available on engagement-free actions with Engagement Identities only. [Learn more](/v1/runs/overview#incremental-sync-mode)
* **Continue a Run** — New endpoint [`POST /v1/runs/{run_uid}/continue`](/v1/api/runs/continue) to trigger incremental updates on async runs.
* **Cursor-based pagination on run outputs & inputs** — `/v1/runs/{run_uid}/outputs` and `/v1/runs/{run_uid}/inputs` now use cursor-based pagination by default via `X-Pagination-Next`. The `offset` parameter is deprecated. [Pagination guide](/v1/runs/pagination#paginating-run-outputs--inputs)
### Improvements
* **Proxy Retry Logic** — `502` proxy errors are now retried internally with sticky IP fallback before being returned, reducing transient failures.
* **Identity Sync** — Webhook notifications are no longer sent during pending in-app challenges.
* `LK_BAD_COOKIE` errors now return the affected `identity_uid`.
* **Identity `is_active` property** — Identities now expose an `is_active` field. Inactive engagement identities are excluded from subscription renewals.
* **Output: `headline` deprecated, use `summary`** — On Search Sales Navigator People, Saved People, Company Employees, Search LinkedIn People, and Search LinkedIn Company Employees, the `headline` output is deprecated (retroactive). Use **`summary`**, which now correctly contains the profile summary; `headline` was a naming mistake. [Action docs](/v1/api/actions/salesnavigator-search-people).
* **Extract Sales Navigator Company** — New action. Inputs: **`sales_navigator_company_url`** or **`sales_navigator_company_id`**. Outputs include **`country`**, **`city`**, **`postalCode`** and full company profile data. [Action docs](/v1/api/actions/salesnavigator-extract-company).
### App
* **Subscription & pricing display** — Credits plan: discounted **base\_prices** and **total\_price** when a credit discount applies; **total\_price** when a global discount applies. **Engagement identities**: count and **total\_price** (with discount when applicable) are shown; engagement price is added to the selected plan total so you see the full amount (credits + engagement identities). Subscription modal shows the credit plan total with or without discounts applied.
* **`LIMIT_REACHED` errors** — Now include **`params.appendix`** and **`params.timespan`** to distinguish the limit: third-party API (`API_FUSE_LIMIT` daily, `API_RATE_LIMIT` per minute) vs product limits (`MINUTE_LIMIT`, `DAILY_LIMIT`). Integrations should inspect **`appendix`** for better retry logic. [Rate Limits](/v1/runs/rate-limits#differentiating-limit_reached-with-appendix) · [Error Reference](/v1/error-reference).
### Documentation
* **Engagement Identity pricing** — Billing is based on the **peak number of active Engagement Identities** during the month. Documented when an Engagement Identity is active (LinkedIn integration added or action called) vs inactive (30 days without any action, or 5 days after syncing without calling an action). [Engagement Identities](/v1/identities/engagement#pricing--billing)
* **Error Reference** — Error page updated: expanded [Quick Reference Table](/v1/error-reference#quick-reference-table) with all error labels, HTTP codes, categories, and retry guidance; [Error scopes](/v1/error-reference#understanding-error-scopes); [Handling 429](/v1/error-reference#handling-rate-limit-errors-429) (Edges vs LinkedIn, `params.appendix` / `params.timespan`); [Handling 424](/v1/error-reference#handling-linkedin-errors-424) LinkedIn errors with example code. [Error Reference](/v1/error-reference)
### API
* **Extract Sales Navigator Company** — New action to extract full Sales Navigator company data (revenue, description, employee counts, etc.) from a company page. [Extract Sales Navigator Company](/v1/api/actions/salesnavigator-extract-company)
### Improvements & Fixes
* **Extract LinkedIn Conversations** — Maximum conversations limit increased to 15,000; related validations updated. Error handling improved.
* **Extract LinkedIn School Alumnis** — Maximum alumni results limit set to 1,000.
* **Extract LinkedIn Company Affiliates** — Added safe optional chaining when accessing organization data to avoid runtime errors on missing fields.
### API
* **Extract LinkedIn Company Viewers** — New action to extract viewers of a LinkedIn company page. Requires page admin access and a Premium page; returns viewers from the past year. [Extract LinkedIn Company Viewers](/v1/api/actions/linkedin-extract-company-viewers)
* **Extract LinkedIn People Educations** — New action to extract education history (schools, degrees, fields of study, dates). [Extract LinkedIn People Educations](/v1/api/actions/linkedin-extract-people-educations)
* **Extract LinkedIn People — Education output** — New fields: `title` (degree + field of study), `field_of_study`, `school_description`. **Breaking:** `degree_name` is now correctly filled (first part of `title` before comma) or empty; it was previously sometimes filled with `field_of_study`.
* **ID type changes** — Several IDs changed from string to integer: `linkedin_school_id`, `linkedin_company_id`, `original_linkedin_company_id`, `company_id` in extract-people, experiences, company, company-employees-insights, recruiter-lite-search-people.
* **LinkedIn experience outputs** — Added `job_contract_type`, unblocking richer profile refresh data for migrations.
* **Outputs APIs** — Added `extracted_at` so consumers can reliably track when data was fetched.
* **Extract LinkedIn People Post/React/Comment Activity** — Output restructure:
* **Deleted:** `linkedin_original_post_url`
* **Deprecated:** `original_author`
* **Added** `source_post`: source post info (2nd level) with `linkedin_post_id`, `linkedin_post_url`, `content`, `author`; returns `null` when no 2nd level post
* **Added** `linkedin_activity_id`: unique ID depending on post type (original, simple reshare, reshare with comment)
* **Added** `activity_author`: person who performs the activity
* **Updated** `author`: now correctly filled with the author of the first-level (visible) post
* [Post levels table](https://www.notion.so/linkedin-extract-people-post-activity-2e818c28ccb280a5981dc18a54682e17?pvs=21)
### Improvements & Fixes
* **Billing** — Next billed amount displayed on the platform now takes into account any discount applied on the subscription.
* **Sales Navigator** — Fixed company keyword search when spaces were double-encoded, restoring results for multi-word queries.
* **Runs** — Treated `STATUS_404` and `NO_RESULT` as successful “no data” outcomes, reducing false failed runs while keeping transparency via `last_info`.
* **Experience location** — Improved completeness by inheriting the parent location when sub-experiences omit it.
* **Accounts** — Prevents false "no access" errors for some valid accounts.
### Post Activity — Known Limitations
* **Group posts:** When the post is a group post, `author` may be empty (not handled).
* **Component posts:** Some posts (e.g. `article`, `conversationComponent`) may not have an `author` or require alternative resolution.
### API
* **Get Run Inputs** — New endpoint to list all inputs for a run (including failed) and their errors. [Get Run Inputs](/v1/api/runs/inputs)
* **Runs** — Error responses 404/409/422 added on run endpoints; `auth_type` removed from account schemas.
### Documentation
* **Callbacks** — Data completeness: “all” vs “final” modes, how to verify and fetch results. [Managing Callbacks](/v1/runs/callbacks)
* **Extract Post Activity** — “Understanding Author Fields” (author, activity\_author, source\_post). [Extract LinkedIn People Post Activity](/v1/api/actions/linkedin-extract-people-post-activity#understanding-author-fields)
* **Run Outputs** — Not available for live runs (explicit 422). [Get Run Outputs](/v1/api/runs/outputs)
* **Runs overview** — Get run inputs added to [endpoints table](/v1/runs/overview#available-endpoints-for-runs).
* **Search Company Employees** — Reuse a people search URL on a company in one call. [Search Sales Navigator Company Employees](/v1/api/actions/salesnavigator-search-company-employees)
* **Message & InMail** — Voice/video format detection and conversion; Sales Navigator InMail unchanged. [Message](/v1/api/actions/linkedin-message-profile) · [InMail](/v1/api/actions/linkedin-inmail-profile)
### Improvements & Fixes
* **Run Outputs** — Pagination fix; 422 for live runs instead of empty response.
* **Workspace** — OAuth page white-label (your logo); credit override no longer blocks when below plan.
* **Retries** — Internal automatic retries (proxy, limits, Sales Navigator). Do not change your implementation, but decrease error rates.
* **Actions** — `linkedin_profile_id` in more outputs; Search Metrics returns 0 values and supports `#` in URLs; Post Activity returns `linkedin_activity_id`; identities list pagination fixed.
### What This Means for You
* **Recover missed data** — New inputs endpoint and clearer callback rules.
* **Voice & video** — Message and InMail send audio/video as voice or video messages where supported.
* **Company search** — Reuse a people search on a company in one call.
* **Fewer manual retries** — More cases trigger automatic retry.
* **Clearer API** — Pagination fixed; live runs return explicit error.
* **Workspace** — OAuth logo, credit override fix.
### Deprecations
#### Page-Based Pagination Deprecated (Live Mode)
The `page` parameter is now **deprecated** in favor of cursor-based pagination on 38 live mode endpoints.
| Parameter | Status |
| --------- | ---------------------------------------------------- |
| `page` | **Deprecated** (still functional, removed from docs) |
| `token` | **Deprecated** (still functional, removed from docs) |
| `cursor` | **New** - recommended approach |
> The deprecated parameters remain backward compatible. Existing integrations will continue to work, but we recommend migrating to cursors for new implementations.
**Migration steps:**
1. Replace `page` parameter with `cursor`
2. Replace `token` parameter usage with `cursor`
3. Use the `cursor` value from `X-Pagination-Next` header
4. Handle cursor expiration - cursors expire after **24 hours** (restart from beginning if error)
**Affected endpoints:** 38 action `/run/live` endpoints (e.g., `linkedin-extract-*`, `salesnavigator-*`, `recruiterlite-*`)
**Not affected:** Core API endpoints (`/runs`, `/schedules`) continue using `limit/offset` pagination.
### Improvements
* **Unified pagination**: Single cursor approach replaces mixed page/token system
* **Data consistency**: Cursors ensure stable pagination (valid for 24 hours)
* **Simpler implementation**: Always follow `X-Pagination-Next` header (no need to distinguish pagination types)
### API Parameter Updates
* `run_uid` path parameter now includes UUID format validation and description
### What This Means for You
* **Existing integrations continue to work** - `page` and `token` remain functional (backward compatible)
* **New integrations should use `cursor`** - recommended for all new implementations
* **Async/Schedule modes unchanged** - automatic pagination continues to work the same way
* **SDK users**: The `nextPage` helper still works - it returns the cursor URL
### 🚀 What's New
This release focuses on improved LinkedIn reliability, richer profile data, and new automation features.
### 🔒 LinkedIn Connection Reliability
* **Fixed**: LinkedIn accounts now reconnect smoothly without false authentication errors
* **Fixed**: Sales Navigator "upgrade required" errors no longer appear when visiting profiles within your daily limits
* Users should experience far fewer connection interruptions when running LinkedIn workflows
### 📬 LinkedIn Invitation Management
New actions for managing your LinkedIn invitations with precision:
| Action | Description |
| ------------------------ | --------------------------------------------------------------- |
| **Accept Invitation** | Accept a single invitation provided as input |
| **Withdraw Invitation** | Withdraw a single invitation provided as input |
| **Accept Invitations** | Accept all pending invitations (now supports async execution) |
| **Withdraw Invitations** | Withdraw all pending invitations (now supports async execution) |
These actions enable selective invitation workflows, giving you precise control over which invitations to accept or decline.
### 💰 Richer LinkedIn Profile Data
When searching LinkedIn Sales Navigator, you now get enhanced profile information:
* **Dynamic headlines** shown by LinkedIn
* **Job summaries** and descriptions
* **Work experience details** previously unavailable
This richer data enables better targeting and more personalized outreach.
### ⚡ One-Shot Callbacks for Automation Tools
New callback option for customers using automation platforms like n8n, Make, or Zapier:
* Receive **one notification when a job finishes** instead of multiple callbacks during execution
* Dramatically reduces costs for webhook-based integrations
* Set `callback.on` to `final` instead of `all` to enable this mode
### 📊 Better Run Visibility
* **Output counts** are now visible directly in run details
* Know exactly how many results each run produced
* Clearer ROI tracking and performance monitoring
### 🔐 Clearer Error Messages
When LinkedIn credentials are invalid, you now receive clear, actionable error messages instead of confusing codes. This makes troubleshooting faster and reduces frustration.
### 📝 What This Means for You
* **More Reliable**: LinkedIn authentication and Sales Navigator access issues are resolved
* **Better Targeting**: Richer profile data enables more personalized outreach
* **Lower Integration Costs**: One-shot callbacks can reduce automation platform costs significantly
* **Clearer Insights**: See exactly what each run produces with output counts
### 🚀 What's New
This release enhances Sales Navigator and LinkedIn actions with improved error handling, new callback fields, and standardized error responses.
### 🔔 Scheduled Run Tracking in Callbacks
Callback payloads now include a new field for scheduled runs:
```json theme={null}
{
"scheduled_run_uid": ""
}
```
This UUID field is included when the callback originates from a scheduled run, making it easier to correlate callbacks with their scheduled execution context.
### ✨ Enhanced Error Responses
We've significantly improved error response documentation across Sales Navigator and LinkedIn actions with detailed examples and new status codes:
| Status Code | Description | Change |
| ---------------------------- | -------------------------------------- | ------------------------------- |
| **400** Bad Request | Invalid parameters or input | Now includes detailed examples |
| **402** Payment Required | Access denied due to plan limitations | **New** |
| **422** Unprocessable Entity | Action aborted | **New** |
| **424** Failed Dependency | Integration or external service errors | Expanded with multiple examples |
| **429** Too Many Requests | Rate limit exceeded | **New** (replaces 500) |
#### Rate Limit Response Details
429 responses now include detailed rate limit information:
```json theme={null}
{
"error": {
"code": 429,
"status": "Too Many Requests",
"details": {
"Retry-After": "60",
"X-RateLimit-Limit": "2",
"X-RateLimit-Reset": "1754402101",
"X-RateLimit-Type": "/v1/actions"
},
"message": "Rate limit exceeded (/v1/actions)"
}
}
```
### 🔧 Bug Fixes & Improvements
#### LinkedIn Post Extraction
* 🐛 Sanitize LinkedIn post URLs by stripping query parameters to avoid duplicate/mismatched post references and improve cache/canonicalization correctness
#### Identity and Authentication
* ✨ If a `SN_ACCOUNT_UPGRADE` error occurs, the related identity will be ignored for 60 seconds, reducing repeated failures and improving overall action reliability (later, this will apply only to `managed` identities)
#### Cross-Action Error Messaging
* ✨ Standardized error messages across actions for consistency, aligning error codes/messages and improving client-side parsing
### 📝 What This Means for You
* **Better Debugging**: Detailed error examples help identify issues faster
* **Improved Rate Limit Handling**: 429 responses with headers enable smarter retry logic
* **Scheduled Run Correlation**: New `scheduled_run_uid` field links callbacks to their schedule
* **More Reliable Actions**: Automatic identity cooldown on SN upgrade errors prevents cascading failures
* **Cleaner Post URLs**: Post extraction now handles URLs with query parameters correctly
### 🚀 What's New
This release improves LinkedIn invitation handling, adds new output fields for post activity, and standardizes API error responses.
### 🔔 LinkedIn Invitations — Schema Improvements
We've refactored LinkedIn invitation actions for better consistency and reliability:
#### Standardized Invitation Identifiers
All invitation-related actions now use consistent identifiers:
* `linkedin_invitation_id` — String identifier for the invitation
* `linkedin_invitation_urn` — LinkedIn URN for stable reference
| Action | Changes |
| -------------------------------- | ---------------------------------------------------------------- |
| **Accept Invitations** | Simplified input — now requires only `linkedin_invitation_urn` |
| **Extract Received Invitations** | Renamed `sent_time` → `sent_date` for consistency |
| **Extract Sent Invitations** | Now returns `linkedin_invitation_id` + `linkedin_invitation_urn` |
| **Withdraw Invitations** | Output now returns invitation IDs instead of profile URL |
> ⚠️ **Migration Note**: If you're using invitation actions, update your integrations to use the new field names.
### ✨ LinkedIn Post Activity — Author Information
The **People Post Activity** action now includes detailed author information:
* `author` — The person who shared/posted the content
* `original_author` — The original content creator (for reshares)
Both objects include profile identifiers, details (firstname, lastname, headline), URLs, and images.
### 🔧 Bug Fixes & Improvements
#### LinkedIn Post Commenters
* 🐛 Fixed missing `first_name` and `last_name` fields — these were returning empty strings even when `full_name` was populated
#### LinkedIn Post Likers
* 🐛 Removed `linkedin_company_id` from output (field only applied to company likes)
#### LinkedIn Search Content
* ✨ Added `linkedin_company_url` to output
#### InMail & Message File Attachments
* 🐛 Fixed file validation for Base64-encoded attachments
* 🐛 Fixed filename extension validation regex
#### API Error Responses
* ✨ Added standardized error schemas: `PaymentRequired` (402), `Forbidden` (403), `NotFound` (404), `UnprocessableEntity` (422), `TooManyRequests` (429)
#### Pagination
* ✨ Updated default page size to 100 for improved throughput on applicable actions
### 📚 Documentation
* ✨ Added [`POST /runs/{run_uid}/cancel`](/v1/api/runs/cancel) — Cancel an async/schedule run
* ✨ Added [`GET /runs/{run_uid}/status`](/v1/api/runs/status) — Lightweight run status polling
* ✨ Added [`GET /runs/{run_uid}/outputs`](/v1/api/runs/outputs) — Poll for run outputs without callbacks
### 🚀 What's New
Major refactors landed around account rotation and integration limits, introducing caching layers that reduce load and standardize identity handling. HTTP service robustness improved (compressed responses, stricter content-length checks), and several LinkedIn actions received targeted fixes. Run callbacks now include additional identifiers/headers and OpenAPI updates, and error labels were standardized across the stack for clearer diagnostics.
### 🔔 Improved Webhook Delivery Identification & Deduplication
We're introducing two important enhancements to our webhook callback system to make delivery tracking and deduplication more reliable for all integrators.
#### 📌 New Stable Callback Reference (`callback_ref_uid`)
Webhook payloads now include a new field:
```json theme={null}
{
"callback_ref_uid": ""
}
```
This identifier is:
* **Stable across retries**
* **Unique per callback event**
* Designed specifically to allow **safe deduplication** on the client side
This ensures that even if your endpoint receives multiple retries, you can always identify which callbacks correspond to the same logical event.
#### 📌 New Delivery Attempt Headers
Webhook requests now include two additional HTTP headers:
| Header | Description |
| ------------------ | ------------------------------------------------------------------------------------------------- |
| **X-Callback-Ref** | Stable callback identifier, identical across retries (same as `callback_ref_uid` in the payload). |
| **X-Run-Callback** | Unique identifier for each delivery attempt. Changes on every retry. |
These headers allow you to:
* Track each individual delivery attempt
* Log retries more easily
* Distinguish between *event identity* (stable) and *delivery attempt identity* (per retry)
#### 📘 Why this matters
These changes bring our webhook behavior in line with industry best practices and make it easier to:
* Detect and safely ignore duplicate callbacks
* Correlate retries with the same logical event
* Debug delivery attempts via unique identifiers
* Keep payloads stable and idempotent
#### ✅ Summary
* **`callback_ref_uid`** is now included in the payload → *stable event identifier*
* **`X-Callback-Ref`** → stable ID in headers
* **`X-Run-Callback`** → unique per delivery attempt
* Retries always resend the **same payload**, preserving the original run status and data
📘 [Managing Callbacks Documentation](/v1/runs/callbacks)
### 🔧 Action Fixes
#### LinkedIn Job Search
* 🐛 Handled missing job data by throwing a descriptive action error, preventing silent failures.
#### LinkedIn Post Likers Extraction
* 🐛 Removed `linkedin_profile_handle` from the output schema because the source does not provide it.
#### Company Enrichment
* 🐛 Fixed company domain resolution during company enrichment to return the correct domain.
### 🚀 Edges New Release
This release focuses on improving platform stability, reliability, and user experience across LinkedIn automations, engagement identities, and core API functionality.
### 🔒 Improved LinkedIn Session Stability
* **Enhanced IP Management**: Implemented a new progressive IP rotation system that significantly improves LinkedIn session reliability
* **Fewer Connection Errors**: Reduced intermittent failures and reconnection issues during LinkedIn operations
* **Better Error Handling**: More reliable login, refresh, and checkpoint flows with improved retry logic
* **Smoother Workflows**: Users should experience fewer session-related interruptions and more stable automation runs
### 💰 Engagement Identities Billing Enhancements
* **Improved Billing Accuracy**: New buffer mechanism ensures more accurate usage tracking and billing for engagement identities
* **Multiple Plan Tiers**: Support for tiered pricing plans based on usage volume, providing better flexibility and cost optimization
* **Better Timeframe Validation**: Enhanced validation ensures billing stays within subscription timeframes for accurate charges
* **Clearer Error Messages**: Improved error messages when creating identities to distinguish between "No plan available" and "No more room in plan" scenarios
### 📊 Sales Navigator & LinkedIn Actions Improvements
* **Increased Limits**: Sales Navigator company employee search now supports up to **2,500 results** (previously 1,000) per request
* **Enhanced Profile Data**: Company logo URLs are now included in profile experiences when extracting people data
* **Fixed Post-Likers Actions**: Resolved issues with post-likers actions when using "share" URLs as input
* **Better Pagination**: Fixed error 424 issues on multiple-output actions by preventing unnecessary pagination when no results are available
* **Improved Post Commenters**: Enhanced validation for post commenters extraction to handle edge cases more reliably
### 🔧 API & Automation Improvements
* **Output Retrieval by Run UUID**: You can now retrieve outputs directly by Run UUID, making it easier to access run results
* **Better Workflow Support**: Enhanced workflow schemas with improved support for optional steps and output anchoring
* **Real Dates from IDs**: Actions now return accurate dates when retrieving data by ID
### 🛠️ Platform Reliability
* **Automated Data Retention**: Implemented automated cleanup of old runs and usage data to maintain optimal platform performance
* Runs older than 90 days are automatically archived
* Usage records older than 5 days are cleaned up
* This ensures faster queries and better overall system performance
### 📝 What This Means for You
* **More Reliable Automations**: LinkedIn actions should run more smoothly with fewer session interruptions
* **Better Billing Accuracy**: Engagement identities billing is now more precise and transparent
* **Increased Capacity**: Sales Navigator searches can now handle larger result sets
* **Improved Developer Experience**: Better error messages and API capabilities make integration easier
* **Faster Performance**: Automated data retention keeps the platform running smoothly over time
### 🚀 Edges New Release
New release adds several new features and improvements to the Edges platform.
* New [Engagement Identities](/v1/identities/engagement) mode for running LinkedIn outreach actions without consuming credits
* Improved UI overall with updated components for better fluidity and user experience
### 💰 Engagement Identities Pricing & Billing
* **New billing model**: Engagement Identities are billed monthly based on peak usage
* **Starting at \$7.99/identity/month** with dynamic pricing that decreases with volume
* **Credit-free outreach**: Run a comprehensive set of outreach actions (connect, message, follow, engage) without consuming credits
* **Flexible usage**: Convert existing identities to engagement mode or create new ones via API
* **Live monitoring**: Track current billing status and peak usage
📘 [Learn more about Engagement Identities](/v1/identities/engagement)
### 🚀 Update on Extract LinkedIn People
Here are the main changes:
* 👔 **With the experiences parameter**, we now retrieve only the first **five companies' experiences**. The total number may vary depending on the profile. If you want more experiences, use the [`linkedin-extract-people-experiences`](/v1/api/actions/linkedin-extract-people-experiences) endpoint.
* 💡 **With the skills parameter**, we now get only a **few skills (one or two)** — again, this can vary by profile. If you want more skills, use the [`linkedin-extract-people-skills`](/v1/api/actions/linkedin-extract-people-skills) endpoint.
* 📋 Both actions use the same input payload as `linkedin-extract-people`.
* ⚠️ **Note:** these two new actions share the same limit. We'll define the daily and per-minute request limits in a future release.
### 🔧 Technical Updates
* **Rate limit simplification**: Simplified rate limiting system (plans-based rate limits will be introduced in the next release cycle)
### ✨ New Action
* **[Extract LinkedIn Received Invitations](/v1/api/actions/linkedin-extract-received-invitations)** — New `linkedin-extract-received-invitations` action to extract invitations you've received on LinkedIn, including sender details, messages, and timestamps.
### 🔧 Improvements
* **Enhanced LinkedIn Native Login**: Improved stability with broader support for LinkedIn challenge handling, ensuring more reliable authentication flows.
* **Better Profile Data Extraction**: Enhanced "experiences" field parsing in the [`linkedin-extract-people`](/v1/api/actions/linkedin-extract-people) action for more accurate profile information.
* **Live Mode Enhancements**: `custom_data` is now included in both responses and errors for `live` execution mode, improving compatibility with automation tools and making it easier to track and reconcile requests.
### 🚀 Edges New Release
New release adds several new features and improvements to the Edges platform.
* New [Credit Consumption endpoint](/v1/api/workspace/consumption) to track credit usage
* New [Get Identity Limits endpoint](/v1/api/identities/limits) to track limits usage per identity and action
* New [Generate Login Links endpoint](/v1/api/identities/login-links) to create new login links for identities
* Improved documentation and examples in [FAQ](/v1/faq-troubleshooting#how-to-track-credits-consumption%3F), [Native Login](/v1/identities/add-manage-identities#native-linkedin-login-link), and [LinkedIn Limits](/v1/linkedin/limits#2-edges-smart-limits) sections.
### 🔔 Enhanced Integration Webhooks
* **New Event Type**: Added `AUTH_UPDATED` webhook event for monitoring LinkedIn account level changes
* **Enhanced Payload**: Webhook data now includes:
* `name`: LinkedIn account name
* `level`: Account type (Classic, Sales Navigator, Premium, Recruiter Lite)
* **Better Monitoring**: Real-time notifications when users upgrade or change their LinkedIn account levels
📘 [Integration Webhooks Documentation](/v1/identities/linkedin#webhooks)
### 📚 Documentation Improvements
* **API Consistency**: Updated endpoint descriptions from "List all" to "List" for better clarity
* **LinkedIn Limitations**: Added clear documentation about group member extraction limitations
* **Sales Navigator**: Enhanced filtering capabilities with updated OpenAPI specifications
### 🔧 Technical Updates
* Updated OpenAPI specifications with new Sales Navigator filters
* Improved API documentation consistency across all listing endpoints
* Enhanced error handling and limitation documentation
### 🚀 Edges v1 – Public Release
Edges is now publicly available — an API-first automation platform built to run precise, scalable and fully observable actions on top of platforms like LinkedIn and Sales Navigator.
***
### 📦 TypeScript SDK
The [Edges TypeScript SDK](https://www.npmjs.com/package/@edgesrun/sdk) offers a type-safe and minimal way to interact with the Edges API.\
It handles authentication and exposes all endpoints for:
* Action execution (`live`, `async`, `schedule`)
* Identity & integration management
* Run tracking & callbacks
***
### ⚙️ New API Core
Edges exposes a fully documented and production-grade REST API with:
* Modular **actions**, identified by scope (e.g. `linkedin-extract-people`)
* Modern **execution modes**: `live`, `async`, `schedule`
* Strong separation between **members** (dashboard users) and **identities** (automated accounts)
* Robust **pagination**, **rate limits** and **error tracing**
📚 [Explore the full API Reference](/v1/api/)
***
### 👥 Identity-Centric Design
* Identities represent your automation accounts (e.g. a LinkedIn profile)
* Create and manage identities independently from workspace members
* Use native login or cookie-based authentication
* Monitor integration status with webhooks
📘 [How to connect a LinkedIn Identity](/v1/identities/linkedin)
***
### 🔁 Async, Schedule & Callbacks
* Run **bulk actions** at scale via the `async` mode
* Program runs to start **later** (`schedule_at`) or **recurrently** with `cron` via the `schedule` mode
* Provide a `callback_url` to get results pushed when ready
* Enrich callback payloads with your own `custom_data` to simplify reconciliation
📘 [Execution Modes Overview](/v1/runs/overview) & [Async Callback Guide](/v1/runs/callbacks)
***
### ✉️ Featured Actions
* **LinkedIn** Authentication, Extract, Search, Find, Intents, Messaging & Engage
* **Sales Navigator** Search, Metrics & Engage
* **Recruiter Lite** Search
***
### 🧠 Developer Experience First
* Full OpenAPI-based, comprehensive documentation
* Instant authentication with API keys
* Built-in account rotation logic and identity modes
* Tracking and observability with run UIDs, callbacks and callbacks api
* Fast iteration cycles
📘 [Getting Started Guide](/v1/quickstart)
#### LinkedIn Post Activity
* **Added** [Understanding Author Fields](/v1/api/actions/linkedin-extract-people-post-activity#understanding-author-fields) for **Extract LinkedIn People Post Activity**:
* `activity_author` — Person who performs the activity (e.g., reshared).
* `author` — Author of the first-level (visible) post.
* `source_post` — Source post (2nd level) when the visible post is a reshare; includes `author`, `linkedin_post_id`, `linkedin_post_url`, `content_text`; `null` when there is no 2nd level.
* Examples for original post, reshare without comment, reshare with comment, and reshare of a post that shares another post.