canonical: https://jentic.com/apis/help.callingly.com/callingly

# Help Callingly Callingly API

Jentic publishes the only available OpenAPI specification for Callingly API, keeping it validated and agent-ready. Callingly is a lead response automation platform that instantly calls sales reps the moment a new lead arrives so prospects are reached while interest is high. The API exposes call orchestration, lead routing, agent and team management, SMS messaging, multi-tenant client setup for agencies, and webhook subscriptions. It is suited to ops teams wiring Callingly into CRMs, ad platforms, and form tools without rebuilding the dialer logic.

## For AI agents

Trigger outbound calls from new leads, list and update lead records, send SMS, manage agents and teams, and subscribe to call lifecycle webhooks via Callingly.

## Scope

Does not handle CRM contact storage, marketing email, or payment collection - use for outbound sales call orchestration and SMS follow-up only.

## Capabilities

- Trigger an outbound sales call the moment a new lead is captured by posting to /calls
- Route incoming leads to the right team or agent based on routing rules and availability
- Send SMS follow-ups to prospects who do not answer the initial call
- List and filter calls by status, agent, or team to feed dashboards and reporting
- Manage multi-tenant agency clients including activation and deactivation
- Subscribe to webhooks for call connected, completed, and missed events

## Use cases

### Speed-to-Lead Auto Dialing

When a marketing form or ad platform produces a new lead, Callingly can be triggered immediately to call available sales reps and connect them to the prospect, typically within seconds. The API accepts the lead payload, picks an agent based on routing rules, and places the call without requiring a CRM integration. This compresses follow-up time from hours to seconds and lifts contact rates substantially.

Example prompt: POST /calls with the new lead payload, then poll GET `/calls/{call_id}` until status is connected or completed.

### SMS Follow-Up After Missed Calls

If a sales rep cannot reach a prospect on the first attempt, the Callingly API can send a templated SMS through /sms to keep the conversation alive. This is useful for agencies running outbound campaigns where text follow-up converts a missed call into a scheduled callback. The same API surfaces status events via webhooks so the agent can sequence retries.

Example prompt: POST /sms with the lead phone number and a templated follow-up message after a missed call event.

### Multi-Client Agency Management

Marketing agencies running Callingly across many clients can use the /clients endpoints to provision, activate, and deactivate accounts programmatically. This supports onboarding flows where a new client signs up in a portal and Callingly is set up automatically. The same endpoints let an agency pause or resume calling on a per-client basis when budgets change.

Example prompt: POST /clients to create a new agency client, then call POST `/clients/{id}/active` to activate calling for that client.

### AI Agent Sales Outreach Orchestration

An AI agent monitoring inbound lead webhooks from forms or ads can call Callingly through Jentic to fire calls, send SMS, and reassign leads as priorities change. The agent stays out of the dialer logic itself and uses Callingly for orchestration, while Jentic handles credential isolation and operation discovery. This pattern keeps the agent focused on routing and content decisions rather than telephony plumbing.

Example prompt: Search Jentic for 'trigger a sales call', load the Callingly POST /calls schema, and execute it with the lead payload.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/calls` | Trigger an outbound call to a lead |
| GET | `/calls` | List calls with filters |
| GET | `/calls/{call_id}` | Get a call by ID |
| GET | `/leads` | List leads with filters |
| PUT | `/leads/{id}` | Update a lead |
| POST | `/sms` | Send an SMS to a lead |
| POST | `/clients/{id}/active` | Activate or deactivate a client |

## Key resources

- **Calls** — Trigger and inspect outbound sales calls
- **Leads** — Create, update, list, and delete lead records
- **Teams** — Manage sales teams and team membership
- **Agents** — Manage individual sales agents and availability
- **Clients** — Provision and toggle agency client accounts
- **SMS** — Send SMS messages to leads
- **Webhooks** — Subscribe to call and lead lifecycle events

## Why Jentic

- **Setup:** Wiring Callingly by hand means learning its bearer auth, managing the token from your dashboard API keys, and writing your own retry handling around the /calls and /sms endpoints. Through Jentic you install once, import Callingly from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Callingly puts the lead and call id in the URL path (`/leads/{id}`, `/calls/{call_id}`), so a rule can pin your agent to reading and updating those records. You choose the operations it may call, so triggering an outbound call with POST /calls or sending SMS is only included if you add it.
- **Credential handling:** Your Callingly bearer token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'trigger a sales call' or 'send an SMS follow-up', and Jentic returns the matching Callingly operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Twilio API** — Lower-level voice and SMS primitives without lead-routing logic
- **Aircall API** — Cloud phone system with team inboxes and call recording
- **HubSpot Contacts API** — Source of leads that Callingly can dial

## FAQ

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

Callingly does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Callingly API 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 Callingly API use?

Callingly uses HTTP bearer token authentication. Each request must include an Authorization header with a bearer token issued from the Callingly dashboard. When called through Jentic, the bearer token is held in your Jentic One instance and never exposed to the agent context.

### Can I trigger a call to a new lead with the Callingly API?

Yes. POST to /calls with the lead payload (phone, name, source) and Callingly routes the call to an available agent on the configured team. The response includes a call_id that you can poll via GET `/calls/{call_id}` for status updates.

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

Callingly does not document a public rate limit table. In practice, lead-triggered call creation is the highest-volume endpoint and should be paced to match agent capacity. Contact Callingly support for account-specific limits before bulk backfills.

### How do I send an SMS through Callingly via Jentic?

Search Jentic for 'send an sms via callingly', load the schema for POST /sms, and execute with the recipient phone number and message body. Jentic injects the bearer token at execution time.

### Can the Callingly API manage multiple agency clients?

Yes. The /clients endpoints let you list, create, activate, deactivate, and delete client accounts. POST `/clients/{id}/active` toggles calling on or off for a specific client without removing their data.

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

Yes. Because you run Jentic One yourself, your own rules decide which Callingly operations and credentials the agent may use, so you can allow read-only work like GET /leads and PUT `/leads/{id}` while withholding higher-risk actions such as POST /calls to trigger an outbound call or POST /sms to text a prospect. Since Callingly puts the lead and call identifiers in the URL path (`/leads/{id}`, `/calls/{call_id}`), a rule can pin the agent to reading and updating specific records rather than the whole account. The bearer token stays in your own instance and is injected only for the operations you have permitted.