HuskyVoice API, Webhooks, and Workflow Automation

Connect HuskyVoice with your CRM, backend, and business systems to create calls, receive event notifications, trigger actions programmatically, and automate voice workflows end to end.

Create and manage calls via API
Receive real-time call event callbacks
Trigger HuskyVoice actions through inbound webhooks
Run custom functions before, during, and after calls
curl -X POST https://api.huskyvoice.ai/v1/calls \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "agent_123",
    "contact_number": "+919876543210",
    "contact_name": "Raj Patel"
  }'

Choose the right integration method

HuskyVoice provides multiple ways to integrate depending on whether you want direct API control, event delivery, or trigger-based automation.

Calls API

Use API keys to create calls, retrieve call status, and cancel pending calls directly from your backend.

Best for

  • • Server-side applications
  • • CRM integrations
  • • Product integrations

Direction: Your system → HuskyVoice

Authentication: API key

Outbound Webhooks

Receive real-time event notifications from HuskyVoice when call activity happens.

Best for

  • • CRM updates
  • • Analytics pipelines
  • • Event-driven systems

Direction: HuskyVoice → Your system

Authentication: Signing secret

Inbound Webhooks

Trigger HuskyVoice actions by sending POST requests to a unique inbound webhook URL.

Best for

  • • No-code tools
  • • Internal automations
  • • Scheduled jobs

Direction: Your system → HuskyVoice

Authentication: URL token

Workflows

Run custom functions before, during, and after calls. Use call lifecycle workflows to fetch context, perform live lookups, and push call outcomes into your business systems.

Best for

  • • CRM enrichment
  • • Availability checks
  • • Dynamic in-call lookups
  • • Post-call updates
  • • Backend integrations

Direction: Bi-directional

Authentication: Configured in app

Integration methods at a glance

Integration MethodUse CaseDirectionAuthentication
Calls APICreate, retrieve, and cancel calls directlyYour system → HuskyVoiceAPI key
Outbound WebhooksReceive call lifecycle events in your systemHuskyVoice → Your systemSigning secret
Inbound WebhooksTrigger actions using a unique endpointYour system → HuskyVoiceURL token / optional signature
WorkflowsCall lifecycle integrations using custom functionsBi-directionalConfigured in app

Quickstart

The fastest way to get started with HuskyVoice is to create an API key, make your first call, and optionally configure webhooks for real-time updates.

1

Create an account and generate an API key

Sign up for HuskyVoice and generate your API key from the Integrations section inside the application.

2

Create a call

Make your first API call:

curl -X POST https://api.huskyvoice.ai/v1/calls \
  -H "Authorization: Bearer sk_live_your_api_key_here" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: call-request-001" \
  -d '{
    "agent_id": "agent_123",
    "contact_number": "+919876543210",
    "contact_name": "Raj Patel",
    "contact_email": "raj@company.com",
    "additional_info": {
      "company": "Acme Corp",
      "deal_stage": "negotiation"
    }
  }'

Example response:

{
  "data": {
    "call_id": "550e8400-e29b-41d4-a716-446655440000",
    "status": "scheduled"
  }
}
3

Track the call

Retrieve call status using the call ID:

curl -X GET https://api.huskyvoice.ai/v1/calls/550e8400-e29b-41d4-a716-446655440000 \
  -H "Authorization: Bearer sk_live_your_api_key_here"
4

Receive event updates

Configure an outbound webhook in the app to receive notifications such as call.completed, call.failed, and call.initiated.

5

Trigger HuskyVoice from your own systems

Create an inbound webhook in the app and use its unique URL to trigger actions like call.create or call.cancel.

Calls API

Use the HuskyVoice Calls API to schedule outbound calls, retrieve call status, and manage call lifecycle programmatically.

Base URL

https://api.huskyvoice.ai/v1

Authentication

Authenticate every request using your API key in the Authorization header:

Authorization: Bearer sk_live_your_api_key_here

Keep your API key secure and never expose it in client-side code.

India-only in v1

Currently, only Indian phone numbers in +91 E.164 format are supported for call creation through the HuskyVoice v1 Calls API.

Example: +919876543210

Create a Call

Schedule an outbound voice call using a selected HuskyVoice agent.

Endpoint

POST/calls

Full URL

https://api.huskyvoice.ai/v1/calls

Headers

HeaderRequiredDescription
AuthorizationYesBearer API key
Content-TypeYesMust be application/json
Idempotency-KeyRecommendedUnique key used to safely retry create requests without creating duplicate calls

Request body fields

FieldTypeRequiredDescription
agent_idstringYesUnique ID of the HuskyVoice agent that should place the call
contact_numberstringYesContact phone number in +91 E.164 format, for example +919876543210
contact_namestringNoName of the contact
contact_emailstringNoEmail address of the contact
additional_infoobjectNoAdditional metadata to attach to the call, such as CRM fields, company name, or deal context

Example request body

{
  "agent_id": "agent_123",
  "contact_number": "+919876543210",
  "contact_name": "Raj Patel",
  "contact_email": "raj@company.com",
  "additional_info": {
    "company": "Acme Corp",
    "deal_stage": "negotiation"
  }
}

Example response

{
  "data": {
    "call_id": "550e8400-e29b-41d4-a716-446655440000",
    "status": "scheduled"
  }
}

Notes

  • • agent_id must belong to your workspace.
  • • contact_number must be a valid Indian phone number in +91 format.
  • • additional_info can be used to pass business or CRM context for downstream workflows.

Get Call Status

Retrieve details and the current status for a previously created call.

Endpoint

GET/calls/{call_id}

Full URL

https://api.huskyvoice.ai/v1/calls/{call_id}

Path parameters

ParameterTypeRequiredDescription
call_idstringYesUnique identifier of the call

Example response

{
  "data": {
    "call_id": "550e8400-e29b-41d4-a716-446655440000",
    "status": "scheduled",
    "agent_id": "agent_123",
    "contact_number": "+919876543210",
    "contact_name": "Raj Patel",
    "contact_email": "raj@company.com",
    "additional_info": {
      "company": "Acme Corp"
    },
    "scheduled_at": "2024-01-27T03:02:00.000Z",
    "completed_at": null,
    "error": null,
    "created_at": "2024-01-27T03:00:00.000Z",
    "updated_at": "2024-01-27T03:00:00.000Z"
  }
}

Cancel a Call

Cancel a call that has not yet started.

Endpoint

POST/calls/{call_id}/cancel

Full URL

https://api.huskyvoice.ai/v1/calls/{call_id}/cancel

Path parameters

ParameterTypeRequiredDescription
call_idstringYesUnique identifier of the call to cancel

Example response

{
  "data": {
    "call_id": "550e8400-e29b-41d4-a716-446655440000",
    "status": "cancelled",
    "cancelled_at": "2024-01-27T03:01:00.000Z"
  }
}

Error Handling

The API uses standard HTTP status codes and returns structured error objects. Always check the error response to understand what went wrong.

Common HTTP status codes

400Bad Request

The request is malformed or contains invalid data.

401Unauthorized

The API key is missing or invalid.

404Not Found

The requested resource does not exist.

409Conflict

The requested action cannot be performed in the current state.

429Too Many Requests

Too many requests were sent. Please retry later.

500Internal Server Error

An unexpected error occurred on the server.

Error response format

All error responses follow this structure:

{
  "error": {
    "code": "invalid_request",
    "message": "contact_number must be a valid +91 E.164 phone number."
  }
}

Example error — 401 Unauthorized

{
  "error": {
    "code": "unauthorized",
    "message": "Invalid API key."
  }
}

Example error — 409 Conflict

{
  "error": {
    "code": "call_not_cancellable",
    "message": "This call has already started or completed."
  }
}

Rate Limits & Best Practices

Rate limiting

API requests are rate limited per workspace and API key to ensure platform stability. If you exceed the limit, you will receive a 429 Too Many Requests response.

If you need higher throughput for production workflows, please contact support.

Contact us for rate limit increases

support@huskyvoice.ai

Best practices

  • Always store and reuse the returned call_id for subsequent operations
  • Use Idempotency-Key header when creating calls to handle retries safely
  • Validate phone numbers before sending API requests
  • Handle terminal and non-terminal call states correctly in your logic
  • Never expose API keys in browser-based or mobile client code
  • Use the additional_info field to attach CRM or business context

Typical integration flow

  1. 1Generate an API key from the Integrations section
  2. 2Create a call using POST /calls
  3. 3Save the returned call_id for tracking
  4. 4Fetch the latest call state using GET /calls/{call_id}
  5. 5If needed, cancel the call using POST /calls/{call_id}/cancel while it is still cancellable

Support

Need help with your integration? We're here to assist.

Contact Support

Email: support@huskyvoice.ai

Outbound Webhooks

HuskyVoice → Your system

Use outbound webhooks to receive real-time event notifications from HuskyVoice in your application, backend, or workflow system.

Available events

EventDescription
call.completedFired when a call finishes successfully
call.failedFired when a call fails due to a technical or delivery issue
call.disallowedFired when a call is blocked before execution due to policy or account restrictions
call.initiatedFired when a call is successfully triggered

Example payload

{
  "event_id": "evt_abc123",
  "event_type": "call.completed",
  "created_at": "2024-01-15T10:15:00Z",
  "data": {
    "call_id": "call_456",
    "agent_id": "agent_789",
    "phone_number": "+919876543210",
    "duration_seconds": 180,
    "outcome": "successful",
    "summary": "Customer inquiry resolved."
  }
}

Signature verification

Each delivery can be verified using the webhook signing secret configured when you add the webhook in the HuskyVoice application.

Example header:

X-Webhook-Signature: <signature>

Retry policy

Failed webhook deliveries are retried automatically. Your endpoint should return a 2xx response within the expected timeout window to avoid repeated retries or automatic disablement.

Configure outbound webhooks in-app

Add your endpoint, choose events, and manage delivery status from the Integrations section.

Inbound Webhooks

Your system → HuskyVoice

Use inbound webhooks when you want an external system, no-code tool, scheduler, or internal automation to trigger HuskyVoice actions by sending a POST request to a unique webhook URL.

How it works

Each inbound webhook has a unique URL generated inside the HuskyVoice application. Your system can send a JSON payload containing an action and a data object.

Supported actions

ActionDescription
call.createCreate and schedule a new call
call.cancelCancel a call that has not yet started

Example request — call.create

{
  "action": "call.create",
  "data": {
    "agent_id": "your_agent_id",
    "contact_number": "+919876543210",
    "contact_name": "John Doe",
    "contact_email": "john@example.com",
    "additional_info": {
      "deal_id": "D-100"
    }
  }
}

Example request — call.cancel

{
  "action": "call.cancel",
  "data": {
    "call_id": "the-call-id-to-cancel"
  }
}

cURL example

curl -X POST https://api.huskyvoice.ai/v1/hooks/tok_xxxxxxxxxxxxxxxxx \
  -H "Content-Type: application/json" \
  -d '{
    "action": "call.create",
    "data": {
      "agent_id": "your_agent_id",
      "contact_number": "+919876543210",
      "contact_name": "John Doe"
    }
  }'

Authentication

Requests are authenticated using the secret token embedded in the inbound webhook URL. Treat this URL as a secret. Anyone with access to it may be able to trigger HuskyVoice actions on your behalf.

Security best practices

  • Store the inbound webhook URL securely.
  • Do not expose it in browser-based or mobile client code.
  • Rotate the webhook URL immediately if it is shared or exposed.
  • Use optional signature verification for additional protection where supported.

Token rotation

You can rotate the inbound webhook URL from the HuskyVoice application if needed.

Create an inbound webhook in-app

Generate your unique endpoint and start triggering HuskyVoice from external systems.

Workflows

Custom functions across the call lifecycle

Use Workflows to integrate HuskyVoice with your systems before, during, and after calls. Workflows let you run custom functions at key stages of the call lifecycle so agents can fetch external data, act on user responses, and send outcomes to downstream systems.

Pre-call workflows

Run functions before the call starts to prepare the agent with the right context.

Examples:

  • Fetch customer profile data
  • Retrieve account or lead context
  • Check service or interview details
  • Personalize the conversation before the call begins

During-call workflows

Run functions while the conversation is in progress.

Examples:

  • Perform live data lookups
  • Fetch service availability
  • Retrieve interview or booking details
  • Respond dynamically based on customer input

Post-call workflows

Run functions after the call ends to update external systems and trigger follow-up actions.

Examples:

  • Update CRM or ATS records
  • Send call summaries to backend systems
  • Store outcomes in internal databases
  • Trigger downstream notifications or automations

Typical workflow action

A workflow action can call an external API or custom function to fetch or send data as part of the call flow.

Configure custom functions in HuskyVoice

Set up pre-call, during-call, and post-call integrations from the Integrations section in your HuskyVoice workspace.

Security & Reliability

HuskyVoice provides multiple controls to help secure integrations and improve delivery reliability across API requests, outbound webhooks, and inbound webhooks.

API key authentication

Use API keys for direct Calls API access. Store API keys securely and use them only in server-side environments.

Webhook verification

Outbound webhook deliveries can be verified using signing secrets so your system can validate that incoming requests originated from HuskyVoice.

Inbound webhook protection

Inbound webhook URLs are authenticated using embedded secret tokens. Treat each inbound webhook URL as a secret and rotate it immediately if it is exposed.

Idempotency support

Use the Idempotency-Key header when creating calls to safely retry requests without creating duplicate calls.

Retry handling

Failed outbound webhook deliveries are retried automatically. Repeated failures may result in the endpoint being disabled until the issue is resolved.

Rate limits

API requests may be rate limited per workspace or API key to help maintain platform stability and fair usage.

Frequently asked questions

What is the difference between the Calls API and Inbound Webhooks?

The Calls API is designed for direct authenticated server-side integration using API keys. Inbound webhooks are useful when you want an external system or automation tool to trigger HuskyVoice actions using a unique endpoint URL.

What is the difference between Outbound Webhooks and Inbound Webhooks?

Outbound webhooks send events from HuskyVoice to your system. Inbound webhooks let your system send actions into HuskyVoice.

Do I need an account to get API access?

Yes. You need a HuskyVoice account to generate API keys, configure outbound webhooks, and create inbound webhook URLs.

Which call events are available through outbound webhooks?

Available events currently include call.completed, call.failed, call.disallowed, and call.initiated.

Are only Indian phone numbers supported?

For the current v1 Calls API flow, only Indian phone numbers in +91 E.164 format are supported.

Can I use tools like n8n or other automation systems?

Yes. Inbound webhooks are especially useful for tools and systems that can send POST requests.

What are Workflows in HuskyVoice?

Workflows allow you to run custom functions at different stages of the call lifecycle — before the call starts (pre-call), during the conversation (during-call), and after the call ends (post-call). They are useful for fetching data, performing live lookups, and updating external systems.

Ready to integrate HuskyVoice with your systems?

Create your account to generate API keys, configure outbound webhooks, create inbound webhook URLs, and automate voice workflows from one place.