Configure tsconfig.json. Ensure your compiler targets ES2019+ and supports strict mode. Add a path alias if desired:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "resolveJsonModule": true,
    "baseUrl": ".",
    "paths": {
      "twilio-sdk": ["src/twilio-sdk/index.ts"]
    }
  }
}

3. Set environment variables. The client reads these automatically if credentials are omitted at construction:

export TWILIO_ACCOUNT_SID=ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
export TWILIO_AUTH_TOKEN=your_auth_token
export TWILIO_CA_BUNDLE=/path/to/ca-bundle.crt   # optional, for SSL interception

4. Import the factory. Use the default export from index.ts:

import TwilioSDK from "./twilio-sdk/index";
const client = TwilioSDK(process.env.TWILIO_ACCOUNT_SID, process.env.TWILIO_AUTH_TOKEN);

5. TypeScript path resolution. If you used paths in step 2, install tsconfig-paths and register it in your entry point or use ts-node -r tsconfig-paths/register.

Public API

TwilioSDK (default export / factory function)

function TwilioSDK(
  accountSid?: string,
  authToken?: string,
  opts?: IClientOpts
): TwilioSDK.Twilio;

The main entry point. Call it as a function to receive a fully initialized Twilio REST client. opts accepts lazyLoading (default true), httpClient, logLevel, autoRetry, maxRetries, and region/edge for routing. Use this whenever you need to make REST API calls to any Twilio product.

TwilioSDK.jwt.AccessToken

class AccessToken {
  constructor(
    accountSid: string,
    keySid: string,
    secret: string,
    options?: AccessToken.TokenOptions
  );
  toJwt(): string;
}

Generates short-lived JWTs for client-side SDKs (Voice, Video, Conversations). Pass keySid (an API Key SID) and secret (API Key secret) - not the main auth token. Add grants before calling toJwt(). Use this in an HTTP endpoint that issues tokens to authenticated frontend users.

TwilioSDK.twiml.VoiceResponse

class VoiceResponse {
  say(attributes: object | string, body?: string): Say;
  dial(attributes?: object | string): Dial;
  gather(attributes?: object): Gather;
  toXml(): string;
}

Builds TwiML XML documents for Twilio voice webhooks. Chain verb methods to construct a response, then call toXml() and return the result with Content-Type: text/xml. Use this in Express route handlers that respond to Twilio voice callbacks.

TwilioSDK.webhooks (namespace)

// from source/webhooks/webhooks.ts - re-exported on the TwilioSDK namespace
function validateRequest(
  authToken: string,
  twilioSignature: string,
  url: string,
  params: Record<string, string>
): boolean;

Validates that an incoming HTTP request genuinely originated from Twilio. Always call this before processing any webhook payload to prevent spoofed requests.

Working examples

Scenario - Send an SMS message

A minimal Express endpoint that sends an outbound SMS and returns the message SID.

import TwilioSDK from "./twilio-sdk/index";

const client = TwilioSDK(
  process.env.TWILIO_ACCOUNT_SID,
  process.env.TWILIO_AUTH_TOKEN
);

async function sendSms(to: string, body: string): Promise<string> {
  const message = await client.messages.create({
    to,
    from: process.env.TWILIO_PHONE_NUMBER!,
    body,
  });
  return message.sid;
}

sendSms("+12015551234", "Hello from twilio-sdk source block")
  .then((sid) => console.log("Sent:", sid))
  .catch(console.error);

Scenario - Generate a Voice TwiML response

An Express route that answers an incoming call and reads a message aloud.

import express from "express";
import TwilioSDK from "./twilio-sdk/index";

const app = express();
app.use(express.urlencoded({ extended: false }));

app.post("/voice", (req, res) => {
  const response = new TwilioSDK.twiml.VoiceResponse();
  response.say({ voice: "alice", language: "en-US" }, "Thanks for calling. Please hold.");
  const dial = response.dial({ callerId: process.env.TWILIO_PHONE_NUMBER });
  // @ts-ignore - dial returns a Dial TwiML node
  dial.number("+12015559999");
  res.type("text/xml").send(response.toXml());
});

app.listen(3000);

Scenario - Issue an Access Token for a browser voice client

A protected API endpoint that mints a Twilio Access Token with a Voice grant.

import TwilioSDK from "./twilio-sdk/index";

const { AccessToken } = TwilioSDK.jwt;
const { VoiceGrant } = AccessToken;

function issueVoiceToken(identity: string): string {
  const token = new AccessToken(
    process.env.TWILIO_ACCOUNT_SID!,
    process.env.TWILIO_API_KEY!,      // API Key SID - not account SID
    process.env.TWILIO_API_SECRET!,   // API Key secret - not auth token
    { identity, ttl: 3600 }
  );

  const voiceGrant = new VoiceGrant({
    outgoingApplicationSid: process.env.TWILIO_TWIML_APP_SID,
    incomingAllow: true,
  });
  token.addGrant(voiceGrant);

  return token.toJwt();
}

// In your Express handler:
// res.json({ token: issueVoiceToken(req.user.id) });

Scenario - Validate an incoming webhook signature

Middleware that rejects requests not signed by Twilio.

import { Request, Response, NextFunction } from "express";
import * as webhooks from "./twilio-sdk/webhooks/webhooks";

export function twilioWebhookGuard(req: Request, res: Response, next: NextFunction) {
  const authToken = process.env.TWILIO_AUTH_TOKEN!;
  const signature = req.headers["x-twilio-signature"] as string;
  const url = `https://${req.headers.host}${req.originalUrl}`;
  const params: Record<string, string> = req.body ?? {};

  const valid = webhooks.validateRequest(authToken, signature, url, params);
  if (!valid) {
    return res.status(403).send("Forbidden");
  }
  next();
}

File walkthrough

• source/index.ts - Assembles and re-exports the entire public API under the TwilioSDK namespace/function.
• source/interfaces.ts - Defines foundational shared types used across the SDK (HttpMethod, Sid, PhoneNumber, ListEachOptions, ListOptions).
• source/auth_strategy/ - Strategy pattern implementations for attaching credentials to outbound requests (Basic Auth, Bearer Token, No-Auth).
• source/base/ - SDK engine: BaseTwilio base class, Domain/Version for URL construction, Page/TokenPage for pagination, RequestClient for HTTP dispatch, RestException for error modeling, serialize/deserialize helpers.
• source/credential_provider/ - Higher-level credential abstractions: client-credentials OAuth flow (ClientCredentialProvider), org-level OAuth (OrgsCredentialProvider), and unauthenticated (NoAuthCredentialProvider).
• source/http/ - Low-level request/response types and bearer token manager classes for OAuth token lifecycle.
• source/jwt/ - JWT factories: AccessToken for client grants, ClientCapability for legacy Capability Tokens, ValidationToken for request signing, and TaskRouterCapability for TaskRouter workers.
• source/rest/ - One subdirectory per Twilio product API (accounts, api, messaging, studio, taskrouter, etc.), each containing auto-generated resource classes.
• source/twiml/ - TwiML XML document builders for Voice, Messaging, and Fax response verbs.
• source/webhooks/ - validateRequest and related helpers for verifying Twilio webhook signatures using HMAC-SHA1.

Common pitfalls and fixes

• Credentials exposed in frontend bundles. Never import this source in browser-side code; always call from a Node.js backend process only.
• API Key vs Auth Token for AccessToken. AccessToken requires an API Key SID (SK...) and API Key secret, not the main TWILIO_AUTH_TOKEN; mixing them yields a 401 at token use time.
• Webhook URL must be the exact public URL. validateRequest is sensitive to protocol, host, path, and query string; behind a reverse proxy, ensure trust proxy is set in Express or reconstruct the URL explicitly.
• esModuleInterop must be true. Several dependencies use CommonJS default exports; without this flag, imports like import dayjs from 'dayjs' will fail at runtime.
• lazyLoading: false increases startup time. All rest sub-modules are loaded eagerly; leave the default true unless you need all resources initialized synchronously.
• scmp is a native-optional constant-time compare. On some Alpine/musl Linux images it may fail to build; pin to the version listed in package.json and ensure node-gyp build tools are present in the Docker image.

Vibe-coding prompt template

I have dropped the Twilio Node.js SDK source (twilio@6.0.0) into `src/twilio-sdk/`
in my project. The integration reference is `USAGE.md` in the same directory.

Please help me integrate this SDK into my existing Node.js/TypeScript project step by step:

1. Read `USAGE.md` for the correct imports, environment variables, and working code snippets.
2. All imports must come from `./src/twilio-sdk/index` (or sub-paths shown in USAGE.md).
3. Do not install the `twilio` npm package; we are using the local source directly.
4. Set up the required runtime dependencies listed in USAGE.md's "Required dependencies" section.
5. Implement the following feature using the real exports documented in USAGE.md: [DESCRIBE YOUR FEATURE HERE - e.g., "an Express POST /sms endpoint that sends an SMS and validates incoming webhook signatures"].
6. Show the complete TypeScript file(s) with all imports resolved to the local source path.
7. Point out any tsconfig.json changes needed for `esModuleInterop` or path aliases.

License and credit

The upstream package is user@example.com, maintained by Twilio Inc. It is released under the MIT License - see source/LICENSE if present, or the npm package page for the canonical license text. Source repository: https://github.com/twilio/twilio-node.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

The full install guide and integration prompts unlock after purchase.

WordPress & WooCommerce Plugins

Free