> ## Documentation Index
> Fetch the complete documentation index at: https://docs.edges.run/llms.txt
> Use this file to discover all available pages before exploring further.
# 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.
The identity limits still apply. The minute, 15-minute, hourly, 4-hour and daily windows are enforced in live mode exactly as they are in async and schedule, and a call that exceeds one returns [`LIMIT_REACHED`](/v1/error-reference#which-limit-was-hit). What live mode does **not** do is pace the work for you: async and schedule queue your calls and space them out, while live fires the moment you call it.
So the limits will stop you — but nothing sits between you and them smoothing the traffic. Bursty, evenly-spaced or parallel calls look like automation well before a quota is reached, which is what triggers throttling, checkpoints and account risk.
**Goal:** mimic **human-like** usage—similar in spirit to what Edges does in async—by spacing work, avoiding parallelism, and adding randomness.
Unpaced live traffic is the quickest way to get an account restricted. LinkedIn answers machine-like timing with throttling, then checkpoints, then restrictions on the account itself. Spacing calls out is what keeps a connected account usable.
In live mode, **pacing is yours to implement** — the quotas are enforced either way, but the spacing between calls is not. If you want that handled for you, 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`).
***
## The quotas still apply
LinkedIn runs several mechanisms to spot activity that doesn't look human. Our per-identity quotas exist to stay underneath them, and they are enforced in live mode exactly as they are in async and schedule — what live mode leaves to you is the spacing between calls.
Every quota by account level, and which actions consume each one.
***
## Related
When to prefer live over async or schedule.
Paging live results with `X-Pagination-Next`.
Which of the five systems can stop a live call.
The per-identity quotas enforced in every mode.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.