---
title: "Dialer SDK: Embed Power and Parallel Calling | Trellus"
description: "A JavaScript dialer SDK for manual, power and parallel calling inside your own app. Build against a mock transport today. Live calling is enabled by Trellus."
source: "https://www.trellus.ai/developers/dialer-sdk"
note: "Text-only copy of the page for AI assistants and agents. Link to the source address, not this file."
site_summary: "https://www.trellus.ai/llms.txt"
---

# Trellus Dialer SDK

A JavaScript dialer SDK for product teams. Put manual, power and parallel calling inside your own interface. Version 0.1.0 is an integration preview.

JavaScript · Framework-neutral · Version 0.1.0

## A dialer you embed in your own product

The Trellus Dialer SDK is a JavaScript library for manual, power and parallel calling inside an interface you own. It has three parts. The headless SDK owns queue scheduling and call state. A transport owns credentials, audio and backend sessions. An optional UI package provides a ready-made interface.

Your code renders the state the SDK publishes and calls its methods when the user acts. The SDK does not depend on React, a browser extension, DOM selectors or any CRM’s task API.

**Integration preview.** Version 0.1.0 is public on npm. Anyone can install it and build against the mock transport. Live calling works only for companies Trellus has set up.

## The two packages

Packages

| Package | What it provides |
| --- | --- |
| `@trellusrelease/dialer-sdk` | The headless dialer: queue scheduling, call state and typed events, plus the Trellus transport and a mock transport. |
| `@trellusrelease/dialer-ui` | An optional interface built on the SDK: calling controls and a read-only session viewer. It has no transport or credentials of its own. |

Entry points

| Export | Import from |
| --- | --- |
| `createDialer` The headless dialer. | `@trellusrelease/dialer-sdk` |
| `createBrowserDialer` Builds a live dialer for the browser. | `@trellusrelease/dialer-sdk/browser` |
| `createTrellusTransport` The live Trellus transport. | `@trellusrelease/dialer-sdk/transport` |
| `createMockTransport` A transport that places no calls, for local work and tests. | `@trellusrelease/dialer-sdk/testing` |
| `mountDialer` Ready-made calling controls. | `@trellusrelease/dialer-ui` |
| `mountSessionViewer` A read-only session viewer. | `@trellusrelease/dialer-ui/sessions` |

Install the SDK and the browser audio dependency

```bash
npm install @trellusrelease/dialer-sdk @twilio/voice-sdk
```

Install the optional interface

```bash
npm install @trellusrelease/dialer-ui
```

Both packages are ES modules with TypeScript declarations. `@twilio/voice-sdk` is needed only for live calling.

## Who it is for

The SDK is for a product team that wants manual, power and parallel calling inside its own interface. You keep your components and your task list. The SDK supplies the dialing state and the methods.

- **Manual:** one call per user action.
- **Power:** one queued call at a time, in list order.
- **Parallel:** several calls at once. The rep is connected to one of them.

If your team calls from a CRM that Trellus already supports, you do not need the SDK. See the [supported integrations](https://www.trellus.ai/integrations). If you want a ready-made calling workspace under your own brand, see [white-label dialing](https://www.trellus.ai/solutions/white-label). For a product-level summary of the SDK, see [the embedded dialer page](https://www.trellus.ai/solutions/embedded-dialer).

## What works without an account

Everything up to a real phone call. The mock transport implements the same contract as the live transport without network or media. It places no calls, does not contact Trellus or Twilio, and needs no account.

- Install both packages from npm.
- Create a dialer, load tasks and start manual, power or parallel runs.
- Simulate what happens to a call, then build every state of your interface against it.
- Build your wrap-up flow and your save hook.
- Mount the optional interface and the session viewer.

Start with the [quickstart](https://www.trellus.ai/developers/dialer-sdk/quickstart).

## How to get live access

Live calling needs four things:

- A Trellus account.
- A rep API key. Your application supplies it through `getApiKey`.
- The Twilio Voice SDK, `@twilio/voice-sdk` version `>=2.18.0 <3`, installed alongside the SDK.
- Enablement by Trellus. A line setting in code does not grant entitlement.

Talk to Trellus about live access. Already have a Trellus account? [Contact Trellus support](https://app.trellus.ai/support). The same request form is on [the embedded dialer page](https://www.trellus.ai/solutions/embedded-dialer#talk).

Setup details are in [Live calling](https://www.trellus.ai/developers/dialer-sdk/live-calling).

## Status and scope

Version 0.1.0 is an integration preview. It is a standalone subset of the Trellus Chrome extension and does not claim full parity with it.

The packages provide dialing primitives and local queue state. They do not:

- Provision reps or phone numbers.
- Deploy a credential proxy.
- Complete tasks in a CRM.
- Guarantee durable call-data delivery.
- Filter do-not-call numbers or calling hours. Your application applies those rules before it passes tasks to the SDK.
- Run voicemail workflows.
- Recover a run. The SDK does not persist queue runs across page reloads, and it has no cross-tab ownership lease.

### Line limits

The headless core accepts `maxLines` from 1 to 10. The supplied Trellus transport and `createBrowserDialer` accept 1 to 4. The effective limit is the smaller of the two. Neither setting grants entitlement.

## Who owns what

Ownership split

| Part | What it owns |
| --- | --- |
| Headless SDK | `createDialer` owns ordered task intake, the manual, power and parallel scheduler, active call capacity, attempt identity, immutable public snapshots, the parallel winner, pause and wrap-up. It knows no credential format, HTTP path, Twilio class, browser DOM or CRM API. |
| Transport | `createTrellusTransport` owns key retrieval, device registration, token refresh, event normalization, transcript corrections and call controls. `createMockTransport` implements the same contract without network or media. |
| Optional UI | `mountDialer` renders the public snapshots and calls SDK methods. It provides mode selection, manual calling, queue controls, audio routes, call controls, transcripts and wrap-up. Mounting performs no registration or dialing. |
| Your application | Rep authentication and account or workspace changes, task sources, contact eligibility and consent policy, effective dialing limits, saving call outcomes and completing your own workflow. |

There is one scheduling loop. The supplied interface and a custom interface both use the same headless instance for every placement and continuation decision. Do not advance the queue from a second timer in your application.

Every call has a stable `attemptId`. A confirmed call also has a Trellus `sessionId`. Your `taskId`, the SDK `attemptId` and the Trellus `sessionId` have different lifetimes. Keep them separate.

## Guides in this section

- [ **Quickstart** ](https://www.trellus.ai/developers/dialer-sdk/quickstart) Install the packages, run the dialer against the mock transport, render snapshots, then start a power or parallel run. No account is needed and no calls are placed.
- [ **API reference** ](https://www.trellus.ai/developers/dialer-sdk/api) The public surface of the headless SDK: createDialer, the task shape, every dialer method, the snapshot, and errors. The package’s TypeScript declarations are the authority.
- [ **Events and sessions** ](https://www.trellus.ai/developers/dialer-sdk/events) Read state with snapshots, react to six typed events, look up confirmed sessions, and treat live transcript text as provisional until the final snapshot arrives.
- [ **Call lifecycle** ](https://www.trellus.ai/developers/dialer-sdk/lifecycle) How manual, power and parallel modes place calls, how a call progresses, what wrap-up requires, and what to do when an outcome is uncertain.
- [ **Live calling** ](https://www.trellus.ai/developers/dialer-sdk/live-calling) Connect the SDK to Trellus telephony with the browser factory or an explicit transport. Live calling needs a Trellus account, a rep API key, the Twilio Voice SDK and enablement by Trellus.
- [ **Optional interface** ](https://www.trellus.ai/developers/dialer-sdk/ui) A small, framework-independent interface built on the SDK. Mount it for manual, power or parallel dialing, theme it with CSS variables, and add a read-only session viewer.