API Reference

new SendookAPI(apiSecret: string, apiUrl?: string)

import SendookAPI from '@sendook/node';

const client = new SendookAPI('your_api_secret');

client.inbox.create(params?: CreateInboxParams): Promise<any>

interface CreateInboxParams {
  name?: string;   // Name for the inbox
  email?: string;  // Email address (e.g., '[email protected]')
}

const inbox = await client.inbox.create({
  name: 'support',
  email: '[email protected]'
});

client.inbox.list(): Promise<any>

const inboxes = await client.inbox.list();

client.inbox.get(inboxId: string): Promise<any>

const inbox = await client.inbox.get('inbox_123');

client.inbox.delete(inboxId: string): Promise<any>

await client.inbox.delete('inbox_123');

client.inbox.message.send(params: SendMessageParams): Promise<any>

interface SendMessageParams {
  inboxId: string;      // The inbox ID to send from
  to: string[];         // Array of recipient email addresses
  cc?: string[];        // Array of CC email addresses (optional)
  bcc?: string[];       // Array of BCC email addresses (optional)
  labels?: string[];    // Array of labels for categorization (optional)
  subject: string;      // Email subject
  text: string;         // Plain text content
  html: string;         // HTML content
}

const result = await client.inbox.message.send({
  inboxId: 'inbox_123',
  to: ['[email protected]'],
  cc: ['[email protected]'],
  bcc: ['[email protected]'],
  labels: ['newsletter'],
  subject: 'Welcome!',
  text: 'Thanks for signing up.',
  html: '<h1>Thanks for signing up!</h1>'
});

client.inbox.message.reply(params: ReplyMessageParams): Promise<any>

interface ReplyMessageParams {
  inboxId: string;      // The inbox ID
  messageId: string;    // The message ID to reply to
  text: string;         // Plain text content
  html: string;         // HTML content
}

const result = await client.inbox.message.reply({
  inboxId: 'inbox_123',
  messageId: 'msg_456',
  text: 'Thanks for your message!',
  html: '<p>Thanks for your message!</p>'
});

client.inbox.message.list(inboxId: string, query?: string): Promise<any>

// List all messages
const messages = await client.inbox.message.list('inbox_123');

// Search messages
const results = await client.inbox.message.list(
  'inbox_123',
  'subject:invoice'
);

client.inbox.message.get(inboxId: string, messageId: string): Promise<any>

const message = await client.inbox.message.get('inbox_123', 'msg_456');

client.inbox.thread.list(inboxId: string): Promise<any>

const threads = await client.inbox.thread.list('inbox_123');

client.inbox.thread.get(inboxId: string, threadId: string): Promise<any>

const thread = await client.inbox.thread.get('inbox_123', 'thread_789');

client.domain.create(params: CreateDomainParams): Promise<any>

interface CreateDomainParams {
  name: string;  // Domain name (e.g., 'yourdomain.com')
}

const domain = await client.domain.create({
  name: 'yourdomain.com'
});

client.domain.get(params: GetDomainParams): Promise<any>

interface GetDomainParams {
  domainId: string;  // The domain ID
}

const domain = await client.domain.get({
  domainId: 'domain_123'
});

client.domain.verify(params: VerifyDomainParams): Promise<any>

interface VerifyDomainParams {
  domainId: string;  // The domain ID
}

const result = await client.domain.verify({
  domainId: 'domain_123'
});

client.domain.dns(params: GetDomainDNSParams): Promise<any>

interface GetDomainDNSParams {
  domainId: string;  // The domain ID
}

const dnsRecords = await client.domain.dns({
  domainId: 'domain_123'
});

client.domain.delete(params: DeleteDomainParams): Promise<any>

interface DeleteDomainParams {
  domainId: string;  // The domain ID
}

await client.domain.delete({
  domainId: 'domain_123'
});

client.webhook.create(params: CreateWebhookParams): Promise<any>

interface CreateWebhookParams {
  url: string;       // Webhook endpoint URL
  events: string[];  // Array of event types to subscribe to
}

const webhook = await client.webhook.create({
  url: 'https://your-app.com/webhooks/sendook',
  events: ['message.received', 'message.sent']
});

client.webhook.list(): Promise<any>

const webhooks = await client.webhook.list();

client.webhook.get(webhookId: string): Promise<any>

const webhook = await client.webhook.get('webhook_123');

client.webhook.test(webhookId: string): Promise<any>

const result = await client.webhook.test('webhook_123');

client.webhook.delete(webhookId: string): Promise<any>

await client.webhook.delete('webhook_123');

client.apiKey.create(params: CreateApiKeyParams): Promise<any>

interface CreateApiKeyParams {
  name: string;  // Name for the API key
}

const apiKey = await client.apiKey.create({
  name: 'Production Key'
});

client.apiKey.list(): Promise<any>

const apiKeys = await client.apiKey.list();

client.apiKey.get(params: GetApiKeyParams): Promise<any>

interface GetApiKeyParams {
  apiKeyId: string;  // The API key ID
}

const apiKey = await client.apiKey.get({
  apiKeyId: 'key_123'
});

client.apiKey.delete(params: DeleteApiKeyParams): Promise<any>

interface DeleteApiKeyParams {
  apiKeyId: string;  // The API key ID
}

await client.apiKey.delete({
  apiKeyId: 'key_123'
});

import type {
  // Method interfaces
  ApiKeyMethods,
  DomainMethods,
  InboxMethods,
  WebhookMethods,
  MessageMethods,
  ThreadMethods,
  
  // Parameter types
  CreateApiKeyParams,
  GetApiKeyParams,
  DeleteApiKeyParams,
  CreateDomainParams,
  GetDomainParams,
  VerifyDomainParams,
  GetDomainDNSParams,
  DeleteDomainParams,
  CreateInboxParams,
  SendMessageParams,
  ReplyMessageParams,
  CreateWebhookParams,
  GetWebhookParams,
  DeleteWebhookParams
} from '@sendook/node';

import SendookAPI from '@sendook/node';
import type { SendMessageParams } from '@sendook/node';

const client = new SendookAPI('your_api_secret');

const messageParams: SendMessageParams = {
  inboxId: 'inbox_123',
  to: ['[email protected]'],
  subject: 'Hello',
  text: 'Hello, world!',
  html: '<p>Hello, world!</p>'
};

await client.inbox.message.send(messageParams);

import SendookAPI from '@sendook/node';
import { AxiosError } from 'axios';

const client = new SendookAPI(process.env.SENDOOK_API_SECRET!);

try {
  const inbox = await client.inbox.create({
    name: 'support'
  });
} catch (error) {
  if (error instanceof AxiosError) {
    if (error.response) {
      // Server responded with error status
      console.error('Status:', error.response.status);
      console.error('Data:', error.response.data);
    } else if (error.request) {
      // Request made but no response received
      console.error('No response from server');
    }
  } else {
    console.error('Error:', error);
  }
}