canonical: https://jentic.com/apis/leverly.com/leverly

# Leverly API

Jentic publishes the only available OpenAPI specification for Leverly API, keeping it validated and agent-ready. Leverly is a speed-to-lead automation platform that connects inbound web leads to a sales rep's phone within seconds. The API exposes endpoints to post new lead inquiries into the call workflow, stop reattempts on a specific lead, retrieve user information, and pull recent call history, giving outbound sales operations a thin programmatic surface around the Leverly auto-dialer.

## For AI agents

Post inbound leads into Leverly's auto-dial workflow, stop reattempts on a number, and retrieve call history for sales follow-up.

## Scope

Does not handle CRM contact storage, email outreach, or full call recording analytics - use for posting leads to the dialler and reading call history only.

## Capabilities

- Submit inbound web leads into Leverly's call workflow via POST `/inquiries/create.json`
- Halt automatic call reattempts for a specific lead phone number through `/inquiries/stop_reattempts`
- Retrieve the authenticated user's account profile from /users
- Pull recent call history records, including outcomes and timestamps, from /callhistory
- Authenticate calls with the username and token query parameters scoped to the Leverly account

## Use cases

### Speed-to-lead from web forms

When a high-intent visitor submits a contact form on the marketing site, an integration posts the lead immediately to POST `/inquiries/create.json.` Leverly then dials an available rep and connects them to the prospect within seconds. This compresses the response window that drives most B2C conversion lift and avoids the typical multi-minute lag of CRM-to-dialler hand-offs.

Example prompt: POST a new inquiry to `/inquiries/create.json` with the prospect's name, phone number, and source campaign id, then confirm a successful response.

### Stop reattempts after conversion

Once a lead has been spoken to or has converted, Leverly should not keep dialling. An integration listens for conversion or call-completion events from the CRM and calls POST `/inquiries/stop_reattempts` with the lead's phone number to halt further auto-dial attempts. This prevents over-contact complaints and keeps reporting accurate.

Example prompt: Call POST `/inquiries/stop_reattempts` with phone '+15551234567' to halt further outbound dial attempts for that lead.

### Call activity reporting

Sales operations teams pull GET /callhistory on a schedule to feed call outcomes into their BI stack. The data lets analysts measure connection rates, time-to-call, and rep productivity over time, complementing CRM-side opportunity tracking with the dialler's view of the funnel top.

Example prompt: Pull GET /callhistory for the previous 7 days, aggregate by rep, and compute connection rate and average talk time.

### AI agent inbound lead routing via Jentic

An AI lead-qualification agent screens inbound chat conversations and, when intent is high, hands the lead to Leverly for an immediate phone connection. Through Jentic the agent searches for 'post a lead for callback', loads POST `/inquiries/create.json`, and executes with the username and token credentials held in your Jentic One instance. The dialer fires within seconds and the agent never sees the raw token.

Example prompt: Use Jentic to search 'post a new lead for instant call back', load `/inquiries/create.json`, and submit the qualified prospect with their name and phone number.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/inquiries/create.json` | Post a new lead inquiry into the dial workflow. |
| POST | `/inquiries/stop_reattempts` | Stop call reattempts for a lead phone number. |
| GET | `/users` | Retrieve the authenticated user's profile. |
| GET | `/callhistory` | Pull recent call history. |

## Key resources

- **Inquiries** — Create new lead inquiries and stop reattempts on existing ones.
- **Users** — Retrieve the authenticated Leverly user's profile.
- **Call History** — Pull historical call records and outcomes.

## Why Jentic

- **Setup:** Wiring the Leverly API by hand means passing your username and token as query parameters on every request, learning which endpoints post leads and read call history, and calling app.leverly.com yourself. Through Jentic you install once, import the Leverly API from the API Directory, store the username and token once, and your agent calls it.
- **Permission scoping:** Leverly carries its target in the request body and query, not as a resource id in the path, so scope the agent to the operations it needs, such as posting a lead or reading call history. You leave out operations like stopping reattempts unless you add them, so it only calls the ones you allow.
- **Credential handling:** Your Leverly username and token are stored once, encrypted, by your own Jentic One instance and injected as query parameters at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'post a lead for instant call back', and Jentic returns the matching Leverly operation such as POST `/inquiries/create.json` with its input schema so the agent calls the right endpoint without browsing the docs.

## Related APIs

- **Twilio API** — Programmable voice and messaging platform that can build custom speed-to-lead and dialler workflows.
- **RingCentral API** — Cloud phone and contact-centre platform with outbound calling and call-tracking APIs.
- **Salesloft API** — Sales engagement platform that can log Leverly call outcomes and sequence follow-ups.

## FAQ

### Why is there no official OpenAPI spec for Leverly API?

Leverly does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Leverly via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Leverly API use?

Leverly authenticates using a username and token passed as query parameters on every request. Through Jentic these credentials are held in your Jentic One instance, so the agent never sees the raw token and the values are never exposed in agent-side logs.

### Can I push a lead into the Leverly auto-dial workflow with this API?

Yes. POST `/inquiries/create.json` submits a new lead with phone number and contact details into the Leverly workflow, which then auto-dials a rep and connects them to the prospect. This is the primary speed-to-lead operation in the API.

### What are the rate limits for the Leverly API?

Leverly does not publish public rate limits for the v1 API. Because the dialer is real-time, treat `/inquiries/create.json` as a low-latency hot path: send each lead exactly once, retry only on network errors, and avoid bulk reposts that could trigger duplicate calls.

### How do I stop further dial attempts for a lead through Jentic?

Install with 'pip install jentic', search for 'stop dialer reattempts for a lead', and Jentic returns POST `/inquiries/stop_reattempts.` Load the schema, supply the phone number, and execute. Jentic injects the username and token query parameters automatically.

### Can I limit what my agent is allowed to do with the Leverly API?

Yes. Because you self-host Jentic One, your own rules decide which Leverly operations the agent may call, so you can grant only what a task needs, such as POST `/inquiries/create.json` to post a lead or GET /callhistory to read call activity. Leverly carries its target in the request body and query rather than as an id in the path, so you scope the agent at the operation level and simply leave out operations you have not allowed, like POST `/inquiries/stop_reattempts.` The username and token are held by your own instance and injected at call time, so the agent only reaches the endpoints you permit.