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.
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 Method | Use Case | Direction | Authentication |
|---|---|---|---|
| Calls API | Create, retrieve, and cancel calls directly | Your system → HuskyVoice | API key |
| Outbound Webhooks | Receive call lifecycle events in your system | HuskyVoice → Your system | Signing secret |
| Inbound Webhooks | Trigger actions using a unique endpoint | Your system → HuskyVoice | URL token / optional signature |
| Workflows | Call lifecycle integrations using custom functions | Bi-directional | Configured 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.
Create an account and generate an API key
Sign up for HuskyVoice and generate your API key from the Integrations section inside the application.
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"
}
}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"
Receive event updates
Configure an outbound webhook in the app to receive notifications such as call.completed, call.failed, and call.initiated.
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/v1Authentication
Authenticate every request using your API key in the Authorization header:
Authorization: Bearer sk_live_your_api_key_hereKeep 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
/callsFull URL
https://api.huskyvoice.ai/v1/callsHeaders
| Header | Required | Description |
|---|---|---|
| Authorization | Yes | Bearer API key |
| Content-Type | Yes | Must be application/json |
| Idempotency-Key | Recommended | Unique key used to safely retry create requests without creating duplicate calls |
Request body fields
| Field | Type | Required | Description |
|---|---|---|---|
| agent_id | string | Yes | Unique ID of the HuskyVoice agent that should place the call |
| contact_number | string | Yes | Contact phone number in +91 E.164 format, for example +919876543210 |
| contact_name | string | No | Name of the contact |
| contact_email | string | No | Email address of the contact |
| additional_info | object | No | Additional 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
/calls/{call_id}Full URL
https://api.huskyvoice.ai/v1/calls/{call_id}Path parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
| call_id | string | Yes | Unique 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
/calls/{call_id}/cancelFull URL
https://api.huskyvoice.ai/v1/calls/{call_id}/cancelPath parameters
| Parameter | Type | Required | Description |
|---|---|---|---|
| call_id | string | Yes | Unique 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
The request is malformed or contains invalid data.
The API key is missing or invalid.
The requested resource does not exist.
The requested action cannot be performed in the current state.
Too many requests were sent. Please retry later.
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
- 1Generate an API key from the Integrations section
- 2Create a call using POST /calls
- 3Save the returned call_id for tracking
- 4Fetch the latest call state using GET /calls/{call_id}
- 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
| Event | Description |
|---|---|
| call.completed | Fired when a call finishes successfully |
| call.failed | Fired when a call fails due to a technical or delivery issue |
| call.disallowed | Fired when a call is blocked before execution due to policy or account restrictions |
| call.initiated | Fired 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.
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
| Action | Description |
|---|---|
| call.create | Create and schedule a new call |
| call.cancel | Cancel 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.
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.
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.