AI Genie

AI Genie plans and sends personalised outreach. See the Genie guide.

Base URL https://api.leadx.in/api/key/protected. Every request needs an apikey header — see Authentication.

21 endpoints.

`GET /genie`

List Genie.

Auth apikey

:::note Used by the web app pages/AIGeniePage.jsx, pages/GenieCampaigns.jsx :::

Query parameters — the standard list contract: p, n, sortBy, sortOrder, searchBy, searchValue, filters, advancedFilters, ids, nids. See Pagination and Filtering.

Response — data is an array of GenieScheduler objects, alongside the pagination fields described in Response format.

cURL
curl -X GET 'https://api.leadx.in/api/key/protected/genie?p=1&n=25' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie?p=1&n=25', {
  method: 'GET',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.get(
    '/genie?p=1&n=25'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie?p=1&n=25',
      {
        method: 'GET',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.get(
    "https://api.leadx.in/api/key/protected/genie?p=1&n=25",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie?p=1&n=25');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie`

Start a Genie run that generates its own audience.

Auth apikey

:::note Used by the web app pages/AIGeniePage.jsx, pages/GenieCampaigns.jsx :::

Prerequisites

Gemini configured and present in your plan — otherwise GeminiNotAvailableInPlan_400. POST /apps/gemini · GET /apps/gemini

Request body

Field	Type	Default	Notes
`prompt`	`string`	—	The outreach goal, in plain language.
`outreachPrompt`	`string`	`""`
`tone`	`string`	`""`	Free text, e.g. `friendly` or `formal`.
`aiType`	`string`	`gemini`	AI provider. Defaults to Gemini.
`type`	`string`	`lead`	What to generate. Defaults to leads.
`enrichmentEnabled`	`boolean`	`false`	Enrich the audience first and hold outreach until it reports back.
`count`	`number`	`25`	Leads to generate. Maximum 50 — otherwise `MaximumLeadsExceeded_400`.
`industry`	`string`	`""`	Narrows the search.
`additionalFilters`	`any`	`{}`	Further narrowing for the generated audience.
`userEnquiryEnabled`	`boolean`	`true`
`campaign`	`boolean`	`false`	Treat the run as a campaign-style send.
`recurring`	`boolean`	`false`	Repeat the run on a cadence.
`intervalMs`	`number`	—	Gap between runs, in milliseconds. Minimum 60000 when `recurring`.
`whitelistedCustom`	`boolean`	`false`	Restrict sourcing to `customWhitelistedDomains`.
`customWhitelistedDomains`	`string[]`	`[]`
`customChannelSelection`	`boolean`	`false`
`customChannels`	`object`	`{}`	Restrict which connected apps may send. Validated against apps you own.
`outreachCadence`	`object`	`{}`	Timing of multi-step follow-ups.
`draft`	`boolean`	—	Create messages for approval instead of sending them.

Response — data is one GenieScheduler object. (Resource deduced from the collections this handler reads, not read off an explicit return.)

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie' \
  -H 'apikey: $LEADX_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
  "prompt": "",
  "outreachPrompt": "",
  "tone": "",
  "aiType": "gemini",
  "type": "lead",
  "enrichmentEnabled": false,
  "count": 25,
  "industry": "",
  "additionalFilters": {},
  "userEnquiryEnabled": true,
  "campaign": false,
  "recurring": false,
  "intervalMs": "",
  "whitelistedCustom": false,
  "customWhitelistedDomains": [],
  "customChannelSelection": false,
  "customChannels": {},
  "outreachCadence": {},
  "draft": ""
}'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "prompt": "",
    "outreachPrompt": "",
    "tone": "",
    "aiType": "gemini",
    "type": "lead",
    "enrichmentEnabled": false,
    "count": 25,
    "industry": "",
    "additionalFilters": {},
    "userEnquiryEnabled": true,
    "campaign": false,
    "recurring": false,
    "intervalMs": "",
    "whitelistedCustom": false,
    "customWhitelistedDomains": [],
    "customChannelSelection": false,
    "customChannels": {},
    "outreachCadence": {},
    "draft": ""
  }),
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie',
    {
      "prompt": "",
      "outreachPrompt": "",
      "tone": "",
      "aiType": "gemini",
      "type": "lead",
      "enrichmentEnabled": false,
      "count": 25,
      "industry": "",
      "additionalFilters": {},
      "userEnquiryEnabled": true,
      "campaign": false,
      "recurring": false,
      "intervalMs": "",
      "whitelistedCustom": false,
      "customWhitelistedDomains": [],
      "customChannelSelection": false,
      "customChannels": {},
      "outreachCadence": {},
      "draft": ""
    }
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
          'Content-Type': 'application/json',
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    req.write(JSON.stringify(payload));
    req.end();
  });

const { data } = await send({
  "prompt": "",
  "outreachPrompt": "",
  "tone": "",
  "aiType": "gemini",
  "type": "lead",
  "enrichmentEnabled": false,
  "count": 25,
  "industry": "",
  "additionalFilters": {},
  "userEnquiryEnabled": true,
  "campaign": false,
  "recurring": false,
  "intervalMs": "",
  "whitelistedCustom": false,
  "customWhitelistedDomains": [],
  "customChannelSelection": false,
  "customChannels": {},
  "outreachCadence": {},
  "draft": ""
});
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    json={
        "prompt": "",
        "outreachPrompt": "",
        "tone": "",
        "aiType": "gemini",
        "type": "lead",
        "enrichmentEnabled": False,
        "count": 25,
        "industry": "",
        "additionalFilters": {},
        "userEnquiryEnabled": True,
        "campaign": False,
        "recurring": False,
        "intervalMs": "",
        "whitelistedCustom": False,
        "customWhitelistedDomains": [],
        "customChannelSelection": False,
        "customChannels": {},
        "outreachCadence": {},
        "draft": ""
    },
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode({
      'prompt': '',
      'outreachPrompt': '',
      'tone': '',
      'aiType': 'gemini',
      'type': 'lead',
      'enrichmentEnabled': false,
      'count': 25,
      'industry': '',
      'additionalFilters': {},
      'userEnquiryEnabled': true,
      'campaign': false,
      'recurring': false,
      'intervalMs': '',
      'whitelistedCustom': false,
      'customWhitelistedDomains': [],
      'customChannelSelection': false,
      'customChannels': {},
      'outreachCadence': {},
      'draft': ''
    }),
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

Errors GeminiNotAvailableInPlan_400 · MaximumLeadsExceeded_400 · PromptRequired_400

`GET /genie/:schedulerId`

Get Genie detail.

Auth apikey

:::note Used by the web app components/GenieCampaignDrawer.jsx, components/GenieContactModal.jsx, pages/AIGeniePage.jsx and 2 more :::

Path parameters

Name
`schedulerId`	Required

Response — data is one GenieScheduler object.

cURL
curl -X GET 'https://api.leadx.in/api/key/protected/genie/SCHEDULERID' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/SCHEDULERID', {
  method: 'GET',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.get(
    '/genie/SCHEDULERID'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/SCHEDULERID',
      {
        method: 'GET',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.get(
    "https://api.leadx.in/api/key/protected/genie/SCHEDULERID",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/SCHEDULERID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`DELETE /genie/:schedulerId`

Delete Genie.

Auth apikey

:::note Used by the web app components/GenieCampaignDrawer.jsx, components/GenieContactModal.jsx, pages/AIGeniePage.jsx and 2 more :::

Path parameters

Name
`schedulerId`	Required

Response — data is one GenieScheduler object. (Resource deduced from the collections this handler reads, not read off an explicit return.)

cURL
curl -X DELETE 'https://api.leadx.in/api/key/protected/genie/SCHEDULERID' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/SCHEDULERID', {
  method: 'DELETE',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.delete(
    '/genie/SCHEDULERID'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/SCHEDULERID',
      {
        method: 'DELETE',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.delete(
    "https://api.leadx.in/api/key/protected/genie/SCHEDULERID",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/SCHEDULERID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'DELETE',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/:schedulerId/approve-all`

Approve all Genie send jobs.

Auth apikey

:::note Used by the web app components/GenieCampaignDrawer.jsx, components/GenieTemplateAccordion.jsx :::

Path parameters

Name
`schedulerId`	Required

Response — data is one SendJob object. (Resource deduced from the collections this handler reads, not read off an explicit return.)

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/approve-all' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/approve-all', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/SCHEDULERID/approve-all'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/approve-all',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/SCHEDULERID/approve-all",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/approve-all');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/:schedulerId/cancel`

Cancel Genie.

Auth apikey

Path parameters

Name
`schedulerId`	Required

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/cancel' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/cancel', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/SCHEDULERID/cancel'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/cancel',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/SCHEDULERID/cancel",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/cancel');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/:schedulerId/draft-all`

Draft all Genie send jobs.

Auth apikey

:::note Used by the web app components/GenieCampaignDrawer.jsx :::

Path parameters

Name
`schedulerId`	Required

Response — data is one SendJob object.

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/draft-all' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/draft-all', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/SCHEDULERID/draft-all'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/draft-all',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/SCHEDULERID/draft-all",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/draft-all');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/:schedulerId/resume-recurring`

Resume recurring Genie.

Auth apikey

Path parameters

Name
`schedulerId`	Required

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/resume-recurring' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/resume-recurring', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/SCHEDULERID/resume-recurring'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/resume-recurring',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/SCHEDULERID/resume-recurring",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/resume-recurring');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/:schedulerId/retry-failed`

Retry failed Genie.

Auth apikey

Path parameters

Name
`schedulerId`	Required

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/retry-failed' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/retry-failed', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/SCHEDULERID/retry-failed'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/retry-failed',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/SCHEDULERID/retry-failed",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/retry-failed');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/:schedulerId/stop-recurring`

Stop recurring Genie.

Auth apikey

Path parameters

Name
`schedulerId`	Required

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/stop-recurring' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/stop-recurring', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/SCHEDULERID/stop-recurring'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/SCHEDULERID/stop-recurring',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/SCHEDULERID/stop-recurring",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/SCHEDULERID/stop-recurring');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/audience-preview`

Resolve a Genie audience selection to a contact count.

Auth apikey

Request body

Field	Type	Default	Notes
`contactIds`	`array`	`[]`
`leadIds`	`array`	`[]`
`segments`		`null`
`tags`		`null`	Tag ids.
`categories`		`null`

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/audience-preview' \
  -H 'apikey: $LEADX_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
  "contactIds": [],
  "leadIds": [],
  "segments": "",
  "tags": "",
  "categories": ""
}'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/audience-preview', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "contactIds": [],
    "leadIds": [],
    "segments": "",
    "tags": "",
    "categories": ""
  }),
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/audience-preview',
    {
      "contactIds": [],
      "leadIds": [],
      "segments": "",
      "tags": "",
      "categories": ""
    }
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/audience-preview',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
          'Content-Type': 'application/json',
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    req.write(JSON.stringify(payload));
    req.end();
  });

const { data } = await send({
  "contactIds": [],
  "leadIds": [],
  "segments": "",
  "tags": "",
  "categories": ""
});
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/audience-preview",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    json={
        "contactIds": [],
        "leadIds": [],
        "segments": "",
        "tags": "",
        "categories": ""
    },
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/audience-preview');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode({
      'contactIds': [],
      'leadIds': [],
      'segments': '',
      'tags': '',
      'categories': ''
    }),
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/from-contacts`

Start a Genie run against an existing audience.

Auth apikey

Prerequisites

Gemini configured and present in your plan. POST /apps/gemini
An audience — any mix of contacts, leads, segments, tags or categories. POST /contact · POST /segment · POST /tag

Request body

Field	Type	Default	Notes
`contactIds`	`array`	`[]`	Any mix of these five selectors — they union into one run.
`leadIds`	`array`	`[]`	Any mix of these five selectors — they union into one run.
`segments`		`null`	Any mix of these five selectors — they union into one run.
`tags`		`null`	Any mix of these five selectors — they union into one run.
`categories`		`null`	Any mix of these five selectors — they union into one run.
`prompt`		—	Optional here — omitted, Genie plans from your company profile and catalogue.
`tone`		`""`	Free text, e.g. `friendly` or `formal`.
`aiType`	`string`	`gemini`	AI provider. Defaults to Gemini.
`enrichmentEnabled`	`boolean`	`false`	Enrich the audience first and hold outreach until it reports back.
`draft`		—	Create messages for approval instead of sending them.

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/from-contacts' \
  -H 'apikey: $LEADX_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
  "contactIds": [],
  "leadIds": [],
  "segments": "",
  "tags": "",
  "categories": "",
  "prompt": "",
  "tone": "",
  "aiType": "gemini",
  "enrichmentEnabled": false,
  "draft": ""
}'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/from-contacts', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "contactIds": [],
    "leadIds": [],
    "segments": "",
    "tags": "",
    "categories": "",
    "prompt": "",
    "tone": "",
    "aiType": "gemini",
    "enrichmentEnabled": false,
    "draft": ""
  }),
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/from-contacts',
    {
      "contactIds": [],
      "leadIds": [],
      "segments": "",
      "tags": "",
      "categories": "",
      "prompt": "",
      "tone": "",
      "aiType": "gemini",
      "enrichmentEnabled": false,
      "draft": ""
    }
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/from-contacts',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
          'Content-Type': 'application/json',
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    req.write(JSON.stringify(payload));
    req.end();
  });

const { data } = await send({
  "contactIds": [],
  "leadIds": [],
  "segments": "",
  "tags": "",
  "categories": "",
  "prompt": "",
  "tone": "",
  "aiType": "gemini",
  "enrichmentEnabled": false,
  "draft": ""
});
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/from-contacts",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    json={
        "contactIds": [],
        "leadIds": [],
        "segments": "",
        "tags": "",
        "categories": "",
        "prompt": "",
        "tone": "",
        "aiType": "gemini",
        "enrichmentEnabled": False,
        "draft": ""
    },
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/from-contacts');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode({
      'contactIds': [],
      'leadIds': [],
      'segments': '',
      'tags': '',
      'categories': '',
      'prompt': '',
      'tone': '',
      'aiType': 'gemini',
      'enrichmentEnabled': false,
      'draft': ''
    }),
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/leads/:leadId/approve-all`

Approve all lead Genie send jobs.

Auth apikey

:::note Used by the web app components/LeadTimeline/GenieBulkActions.jsx :::

Path parameters

Name
`leadId`	Required

Response — data is one SendJob object. (Resource deduced from the collections this handler reads, not read off an explicit return.)

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/leads/LEADID/approve-all' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/leads/LEADID/approve-all', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/leads/LEADID/approve-all'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/leads/LEADID/approve-all',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/leads/LEADID/approve-all",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/leads/LEADID/approve-all');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/leads/:leadId/draft-all`

Draft all lead Genie send jobs.

Auth apikey

Path parameters

Name
`leadId`	Required

Response — data is one SendJob object.

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/leads/LEADID/draft-all' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/leads/LEADID/draft-all', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/leads/LEADID/draft-all'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/leads/LEADID/draft-all',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/leads/LEADID/draft-all",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/leads/LEADID/draft-all');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`GET /genie/leads/:leadId/pending-approvals`

Get lead pending approvals.

Auth apikey

Path parameters

Name
`leadId`	Required

Response — data is one SendJob object. (Resource deduced from the collections this handler reads, not read off an explicit return.)

cURL
curl -X GET 'https://api.leadx.in/api/key/protected/genie/leads/LEADID/pending-approvals' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/leads/LEADID/pending-approvals', {
  method: 'GET',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.get(
    '/genie/leads/LEADID/pending-approvals'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/leads/LEADID/pending-approvals',
      {
        method: 'GET',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.get(
    "https://api.leadx.in/api/key/protected/genie/leads/LEADID/pending-approvals",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/leads/LEADID/pending-approvals');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`GET /genie/leads/:leadId/send-counts`

Get lead Genie send counts.

Auth apikey

:::note Used by the web app components/LeadTimeline/GenieBulkActions.jsx :::

Path parameters

Name
`leadId`	Required

Response — data is one SendJob object. (Resource deduced from the collections this handler reads, not read off an explicit return.)

cURL
curl -X GET 'https://api.leadx.in/api/key/protected/genie/leads/LEADID/send-counts' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/leads/LEADID/send-counts', {
  method: 'GET',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.get(
    '/genie/leads/LEADID/send-counts'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/leads/LEADID/send-counts',
      {
        method: 'GET',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.get(
    "https://api.leadx.in/api/key/protected/genie/leads/LEADID/send-counts",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/leads/LEADID/send-counts');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/send-jobs/:sendJobId/approve`

Approve Genie send job.

Auth apikey

:::note Used by the web app components/GenieCampaignDrawer.jsx, components/LeadTimeline/GenieOutreachActions.jsx :::

Path parameters

Name
`sendJobId`	Required

Response — data is one SendJob object. (Resource deduced from the collections this handler reads, not read off an explicit return.)

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/send-jobs/SENDJOBID/approve' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/send-jobs/SENDJOBID/approve', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/send-jobs/SENDJOBID/approve'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/send-jobs/SENDJOBID/approve',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/send-jobs/SENDJOBID/approve",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/send-jobs/SENDJOBID/approve');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`POST /genie/send-jobs/:sendJobId/draft`

Draft Genie send job.

Auth apikey

:::note Used by the web app components/GenieCampaignDrawer.jsx :::

Path parameters

Name
`sendJobId`	Required

Response — data is one SendJob object.

cURL
curl -X POST 'https://api.leadx.in/api/key/protected/genie/send-jobs/SENDJOBID/draft' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/send-jobs/SENDJOBID/draft', {
  method: 'POST',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.post(
    '/genie/send-jobs/SENDJOBID/draft'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/send-jobs/SENDJOBID/draft',
      {
        method: 'POST',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.post(
    "https://api.leadx.in/api/key/protected/genie/send-jobs/SENDJOBID/draft",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/send-jobs/SENDJOBID/draft');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`GET /genie/settings`

Get Genie settings.

Auth apikey

cURL
curl -X GET 'https://api.leadx.in/api/key/protected/genie/settings' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/settings', {
  method: 'GET',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.get(
    '/genie/settings'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/settings',
      {
        method: 'GET',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.get(
    "https://api.leadx.in/api/key/protected/genie/settings",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/settings');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`PUT /genie/settings`

Update Genie settings.

Auth apikey

cURL
curl -X PUT 'https://api.leadx.in/api/key/protected/genie/settings' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/settings', {
  method: 'PUT',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.put(
    '/genie/settings'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/settings',
      {
        method: 'PUT',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.put(
    "https://api.leadx.in/api/key/protected/genie/settings",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/settings');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'PUT',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

`GET /genie/templates/:templateId`

Get Genie template preview.

Auth apikey

Path parameters

Name
`templateId`	Required

cURL
curl -X GET 'https://api.leadx.in/api/key/protected/genie/templates/TEMPLATEID' \
  -H 'apikey: $LEADX_API_KEY'

fetch
// Node 18+ and every modern browser ship fetch.
const res = await fetch('https://api.leadx.in/api/key/protected/genie/templates/TEMPLATEID', {
  method: 'GET',
  headers: {
    apikey: process.env.LEADX_API_KEY,
  },
});

const payload = await res.json();
if (!res.ok) {
  // Errors carry { status, success, message } — not the success envelope.
  throw new Error(`${res.status} ${payload.message}`);
}

console.log(payload.data);

axios
import axios from 'axios';

const leadx = axios.create({
  baseURL: 'https://api.leadx.in/api/key/protected',
  headers: { apikey: process.env.LEADX_API_KEY },
});

try {
  const { data } = await leadx.get(
    '/genie/templates/TEMPLATEID'
  );
  console.log(data.data);
} catch (err) {
  // axios throws on 4xx/5xx; the envelope is on err.response.data.
  throw new Error(`${err.response?.status} ${err.response?.data?.message ?? err.message}`);
}

Node (no deps)
import { request } from 'node:https';

// The dependency-free version, for somewhere fetch is not available.
const send = (payload) =>
  new Promise((resolve, reject) => {
    const req = request(
      'https://api.leadx.in/api/key/protected/genie/templates/TEMPLATEID',
      {
        method: 'GET',
        headers: {
          apikey: process.env.LEADX_API_KEY,
        },
      },
      (res) => {
        let raw = '';
        res.on('data', (chunk) => { raw += chunk; });
        res.on('end', () => {
          const body = JSON.parse(raw);
          if (res.statusCode >= 400) reject(new Error(`${res.statusCode} ${body.message}`));
          else resolve(body);
        });
      },
    );
    req.on('error', reject);
    
    req.end();
  });

const { data } = await send(null);
console.log(data);

Python
import os
import requests

res = requests.get(
    "https://api.leadx.in/api/key/protected/genie/templates/TEMPLATEID",
    headers={"apikey": os.environ["LEADX_API_KEY"]},
    timeout=30,
)

payload = res.json()
res.raise_for_status()
print(payload["data"])

PHP
<?php
$ch = curl_init('https://api.leadx.in/api/key/protected/genie/templates/TEMPLATEID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST  => 'GET',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'apikey: ' . getenv('LEADX_API_KEY'),
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$payload = json_decode($response, true);
if ($status >= 400) {
    throw new RuntimeException("$status {$payload['message']}");
}

print_r($payload['data']);

GET /genie​

POST /genie​

GET /genie/:schedulerId​

DELETE /genie/:schedulerId​

POST /genie/:schedulerId/approve-all​

POST /genie/:schedulerId/cancel​

POST /genie/:schedulerId/draft-all​

POST /genie/:schedulerId/resume-recurring​

POST /genie/:schedulerId/retry-failed​

POST /genie/:schedulerId/stop-recurring​

POST /genie/audience-preview​

POST /genie/from-contacts​

POST /genie/leads/:leadId/approve-all​

POST /genie/leads/:leadId/draft-all​

GET /genie/leads/:leadId/pending-approvals​

GET /genie/leads/:leadId/send-counts​

POST /genie/send-jobs/:sendJobId/approve​

POST /genie/send-jobs/:sendJobId/draft​

GET /genie/settings​

PUT /genie/settings​

GET /genie/templates/:templateId​

`GET /genie`

`POST /genie`

`GET /genie/:schedulerId`

`DELETE /genie/:schedulerId`

`POST /genie/:schedulerId/approve-all`

`POST /genie/:schedulerId/cancel`

`POST /genie/:schedulerId/draft-all`

`POST /genie/:schedulerId/resume-recurring`

`POST /genie/:schedulerId/retry-failed`

`POST /genie/:schedulerId/stop-recurring`

`POST /genie/audience-preview`

`POST /genie/from-contacts`

`POST /genie/leads/:leadId/approve-all`

`POST /genie/leads/:leadId/draft-all`

`GET /genie/leads/:leadId/pending-approvals`

`GET /genie/leads/:leadId/send-counts`

`POST /genie/send-jobs/:sendJobId/approve`

`POST /genie/send-jobs/:sendJobId/draft`

`GET /genie/settings`

`PUT /genie/settings`

`GET /genie/templates/:templateId`