> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns.
>
> **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal):
> ```bash
> npx -y @scalekit-inc/cli setup -y
> ```
>
> Global:
> ```bash
> npm install -g @scalekit-inc/cli
> scalekit setup -y
> ```
>
> Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`.
> Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim.
> [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/)

---

# Connect AI agents to Emailable

The Emailable connector lets your AI agent act in each user's Emailable account. Each user connects their own Emailable access token once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 4 tools.

**Authentication:** Bearer Token
**Categories:** Marketing, Developer Tools
**Tools:** 4: 2 read, 2 write, 0 destructive
**Users sign in with:** Access token
**Built by:** Scalekit connector
**Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=EMAILABLE)

## Setup

1. ### Install the SDK

   **Node.js**

   ```bash
   npm install @scalekit-sdk/node dotenv
   ```

   **Python**

   ```bash
   pip install scalekit-sdk-python python-dotenv
   ```

2. ### Set your credentials

   Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**.

   ```sh title=".env"
   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>
   ```

3. ### Create the Emailable connection

   In **AgentKit > Connections**, create an Emailable connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/).

4. ### Authorize a user and make your first call

   **Node.js** (`quickstart.mts`)

   ```typescript
   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   import { createInterface } from 'node:readline/promises'

   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENVIRONMENT_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions

   const connector = 'emailable'
   const identifier = 'user_123'

   // Generate an authorization link for the user
   const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier })
   console.log('Authorize Emailable:', link)
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   await rl.question('Press Enter after authorizing...')
   rl.close()

   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'emailable_account_get',
     toolInput: {},
   })
   console.log(result)
   ```

   ```bash
   npx tsx quickstart.mts
   ```

   **Python** (`quickstart.py`)

   ```python
   import os
   from scalekit import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()

   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions

   connection_name = "emailable"
   identifier = "user_123"

   # Generate an authorization link for the user
   link_response = actions.get_authorization_link(
       connection_name=connection_name,
       identifier=identifier,
   )
   print("Authorize Emailable:", link_response.link)
   input("Press Enter after authorizing...")

   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="emailable_account_get",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)
   ```

   ```bash
   python quickstart.py
   ```

   Each user opens the link once and enters their Emailable credentials there. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses.

## Tools

Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool).

**Node.js**

```typescript
const result = await actions.executeTool({
  toolName: 'emailable_account_get',
  toolInput: {},
  connector: 'emailable',
  identifier: 'user_123',
})
```

**Python**

```python
result = actions.execute_tool(
    tool_name="emailable_account_get",
    tool_input={},
    connection_name="emailable",
    identifier="user_123",
)
```

`result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call.

### `emailable_account_get`

Get Account · Read-only

Get the Emailable account's owner email and available verification credits.
Returns owner_email and available_credits.
Use emailable_account_get to check the balance before a verification or batch.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs: none.

Example input: `{}`

### `emailable_batch_get`

Get Batch Verification · Read-only

Get the status and, once finished, the results of an Emailable batch.
While running, returns message, processed and total. When finished, returns id, total_counts by state (with processed and total), reason_counts, and either emails (per-address results, for batches of up to 1,000) or download_file (a link to a zipped CSV, for larger batches). Per-address results are kept for 30 days and download links for 5 days.
Use emailable_batch_get to poll a batch started with emailable_batch_create. Set partial to see results so far for a small batch.
Requires the batch id returned by emailable_batch_create.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `batch_id` (`string`, required): ID of the batch, returned as id by emailable_batch_create. Example: 5cf6dd30093f96d2ac34bb0a.
- `partial` (`boolean`, optional): Set true to include results so far while the batch is still verifying. Only for batches of up to 1,000 emails. Defaults to false. Example: true.
- `simulate` (`string`, optional): With a test key only, simulate a batch state or error. Example: verifying. One of: `generic_error`, `importing`, `verifying`, `paused`.

Example input: `{"batch_id":"<batch_id>"}`

### `emailable_batch_create`

Create Batch Verification · Write

Start verifying a batch of up to 50,000 email addresses in the background and spend one credit per address (test keys spend none).
Returns id (the batch ID) and message. Results are not in the response.
Use emailable_batch_create to verify a list. Use emailable_email_verify for one address. Poll emailable_batch_get with the returned id, or pass callback_url to receive the results when the batch finishes.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `emails` (`array`, required): The email addresses to verify, up to 50,000. Example: ["tim@smith.com", "john@smith.com"].
- `callback_url` (`string`, optional): URL that Emailable sends the batch results to with an HTTP POST when the batch finishes. The body matches emailable_batch_get's output. It must answer 200, or Emailable retries hourly for up to 3 days. Example: http://example.com/callback.
- `response_fields` (`array`, optional): Limit the fields returned for each email in the results to these. All fields are returned when omitted. Example: ["email", "state", "reason"].
- `retries` (`boolean`, optional): Set false to turn off automatic retries for some mail-server responses. That is faster but may return more unknown results. Defaults to true. Example: false.
- `simulate` (`string`, optional): With a test key only, simulate an API response instead of creating a batch. Example: insufficient_credits_error. One of: `generic_error`, `insufficient_credits_error`, `payment_error`.

Example input: `{"emails":["tim@smith.com","john@smith.com"]}`

### `emailable_email_verify`

Verify Email · Write

Verify one email address in real time and spend one Emailable credit (test keys spend none).
Returns state (deliverable, undeliverable, risky or unknown), reason, score, role, free, disposable, accept_all, mailbox_full, no_reply, did_you_mean, domain, mx_record, smtp_provider, user, tag, possible first, last and full name, gender and duration. If verification is still running after the timeout, Emailable answers with status 249 and a message to send the same request again; retrying within 5 minutes costs no extra credit.
Use emailable_email_verify for one address at a time, such as at sign-up. Use emailable_batch_create for a list.

Read only: no. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `email` (`string`, required): The email address to verify. Example: john@smith.com.
- `accept_all` (`boolean`, optional): Set true to run an accept-all (catch-all) check on the domain. It adds a lot of response time. Defaults to false. Example: true.
- `smtp` (`boolean`, optional): Set false to skip the SMTP check. That is much faster but significantly less accurate. Defaults to true. Example: false.
- `timeout` (`integer`, optional): Seconds to wait for a result, 2 to 10. Defaults to 5. Use 8 or less to stay within the tool-call time limit; on a timeout Emailable returns status 249 and you can retry. Example: 5.

Example input: `{"email":"<email>"}`

## Related

Other Marketing connectors ([all 190](/agentkit/connectors/?category=marketing)):

- [HubSpot](/agentkit/connectors/hubspot/): Scalekit connector, OAuth, 457 tools
- [Mailchimp](/agentkit/connectors/mailchimp/): Scalekit connector, OAuth, 73 tools
- [Twitter / X](/agentkit/connectors/twitteroauth/): Scalekit connector, OAuth, 92 tools


---

## More Scalekit documentation

| Resource | What it contains | When to use it |
|----------|-----------------|----------------|
| [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content |
| [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas |
| [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |
