# Create Agent
Source: https://docs.kakiyo.com/api-reference/agents/create
POST /agents
Creates a new agent
## Overview
Create a new LinkedIn automation agent for your team. This endpoint handles the complete agent setup process including profile creation, proxy assignment, and initial configuration. The agent will be ready for campaign assignment once created.
## Request Body
Display name for the agent (used in dashboard and reports)
Email address for the LinkedIn account (must be unique)
Password for the LinkedIn account (minimum 8 characters)
First name for the LinkedIn profile
Last name for the LinkedIn profile
Agent working hours configuration
Start time in HH:MM format
End time in HH:MM format
Timezone for working hours
Working days of the week
Daily activity limits for the agent
Maximum connection requests per day
Maximum messages per day
Maximum profile views per day
## Use Cases
* **Team Expansion**: Add new agents to increase outreach capacity
* **Geographic Coverage**: Create agents for different time zones
* **Campaign Specialization**: Dedicated agents for specific campaigns
* **Load Distribution**: Balance workload across multiple agents
## Request Example
```json theme={null}
{
"name": "Sales Agent - West Coast",
"email": "agent.westcoast@company.com",
"password": "SecurePassword123!",
"firstName": "Sarah",
"lastName": "Johnson",
"workingHours": {
"start": "08:00",
"end": "16:00",
"timezone": "America/Los_Angeles",
"days": ["monday", "tuesday", "wednesday", "thursday", "friday"]
},
"limits": {
"dailyConnections": 25,
"dailyMessages": 60,
"dailyProfileViews": 120
}
}
```
## Response Structure
```json theme={null}
{
"message": "Agent created successfully",
"agent": {
"id": "agent_123",
"name": "Sales Agent - West Coast",
"email": "agent.westcoast@company.com",
"status": "setup_pending",
"healthStatus": "initializing",
"profile": {
"firstName": "Sarah",
"lastName": "Johnson",
"profileId": "gologin_profile_456"
},
"workingHours": {
"start": "08:00",
"end": "16:00",
"timezone": "America/Los_Angeles",
"days": ["monday", "tuesday", "wednesday", "thursday", "friday"]
},
"limits": {
"dailyConnections": 25,
"dailyMessages": 60,
"dailyProfileViews": 120
},
"proxy": {
"assigned": true,
"location": "United States",
"type": "residential"
},
"createdAt": "2024-01-20T15:30:00Z",
"teamId": "team_789"
},
"nextSteps": [
"Complete LinkedIn profile setup",
"Verify email address",
"Configure automation settings",
"Assign to campaigns"
]
}
```
## Testing Example
```bash theme={null}
curl -X POST "https://api.kakiyo.com/v1/agents" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"name": "Sales Agent - West Coast",
"email": "agent.westcoast@company.com",
"password": "SecurePassword123!",
"firstName": "Sarah",
"lastName": "Johnson",
"workingHours": {
"start": "08:00",
"end": "16:00",
"timezone": "America/Los_Angeles"
}
}'
```
```javascript theme={null}
// JavaScript/Node.js
const createAgent = async (agentData) => {
const response = await fetch('https://api.kakiyo.com/v1/agents', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify(agentData)
});
return await response.json();
};
// Usage example
const newAgent = await createAgent({
name: 'Sales Agent - West Coast',
email: 'agent.westcoast@company.com',
password: 'SecurePassword123!',
firstName: 'Sarah',
lastName: 'Johnson',
workingHours: {
start: '08:00',
end: '16:00',
timezone: 'America/Los_Angeles'
},
limits: {
dailyConnections: 25,
dailyMessages: 60,
dailyProfileViews: 120
}
});
console.log('New Agent Created:', newAgent);
```
```python theme={null}
# Python
import requests
def create_agent(agent_data):
"""Create a new LinkedIn agent"""
response = requests.post(
'https://api.kakiyo.com/v1/agents',
json=agent_data,
headers={
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
)
return response.json()
# Usage example
agent_data = {
'name': 'Sales Agent - West Coast',
'email': 'agent.westcoast@company.com',
'password': 'SecurePassword123!',
'firstName': 'Sarah',
'lastName': 'Johnson',
'workingHours': {
'start': '08:00',
'end': '16:00',
'timezone': 'America/Los_Angeles'
},
'limits': {
'dailyConnections': 25,
'dailyMessages': 60,
'dailyProfileViews': 120
}
}
result = create_agent(agent_data)
print('New Agent Created:', result)
```
## Error Responses
### Email Already Exists
```json theme={null}
{
"error": "email_exists",
"message": "An agent with this email already exists"
}
```
### Invalid Email Format
```json theme={null}
{
"error": "invalid_email",
"message": "Please provide a valid email address"
}
```
### Weak Password
```json theme={null}
{
"error": "weak_password",
"message": "Password must be at least 8 characters long"
}
```
### Team Limit Reached
```json theme={null}
{
"error": "agent_limit_reached",
"message": "Maximum number of agents reached for your plan"
}
```
### Proxy Assignment Failed
```json theme={null}
{
"error": "proxy_assignment_failed",
"message": "Unable to assign proxy to agent. Please try again."
}
```
## Best Practices
1. **Unique Emails**: Use unique email addresses for each agent
2. **Strong Passwords**: Use complex passwords with mixed characters
3. **Realistic Limits**: Set conservative daily limits to avoid restrictions
4. **Geographic Distribution**: Create agents in different time zones
5. **Professional Names**: Use professional names for LinkedIn profiles
# Delete agent
Source: https://docs.kakiyo.com/api-reference/agents/delete
DELETE /agents/{id}
**This is a destructive operation that cannot be undone.** Deleting an agent permanently removes all associated data including usage statistics, configuration, and history.
## Overview
Permanently delete an agent and all its associated data. Kakiyo-managed agents must have status `ended`; externally provisioned profiles can be removed when their source lifecycle requires cleanup. The operation removes the agent, its campaigns, and its usage statistics from your account. Kakiyo-managed agents also have their provider resources cleaned up, while externally provisioned profiles keep their externally owned provider resources untouched.
## Prerequisites
* You must have access to the agent (same team)
* Agent must exist in your account
* Kakiyo-managed agents must have status `ended`
* No campaign import can be active for the agent
## Use Cases
* **Account Cleanup**: Remove agents that are no longer needed
* **Data Management**: Clean up ended agents to reduce clutter
* **Resource Management**: Free up agent slots in your account
* **Compliance**: Permanently remove agent data for privacy requirements
## Path Parameters
The unique identifier of the agent to delete
## Response Examples
### Success Response
```json theme={null}
{
"message": "Agent deleted successfully"
}
```
### Error Responses
```json theme={null}
// Agent not found
{
"error": "not_found",
"message": "Agent not found"
}
// No access to agent
{
"error": "forbidden",
"message": "You do not have access to this agent"
}
// Campaign import in progress
{
"error": "campaign_busy",
"message": "Wait for active prospect imports to finish before deleting this profile"
}
// Kakiyo-managed agent is not ended
{
"error": "invalid_status",
"message": "Agent can only be deleted when status is ended",
"currentStatus": "running"
}
// Internal server error
{
"error": "internal_error",
"message": "An internal error occurred"
}
```
## Testing Examples
```bash theme={null}
# Delete an agent
curl -X DELETE "https://api.kakiyo.com/v1/agents/agent_123" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript theme={null}
// JavaScript/Node.js
const deleteAgent = async (agentId) => {
const response = await fetch(`https://api.kakiyo.com/v1/agents/${agentId}`, {
method: 'DELETE',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
if (!response.ok) {
const error = await response.json();
throw new Error(`Failed to delete agent: ${error.message}`);
}
return await response.json();
};
// Usage with error handling
try {
const result = await deleteAgent('agent_123');
console.log('Agent deleted:', result.message);
} catch (error) {
console.error('Delete failed:', error.message);
}
```
```python theme={null}
# Python
import requests
def delete_agent(agent_id):
"""Permanently delete an agent"""
response = requests.delete(
f'https://api.kakiyo.com/v1/agents/{agent_id}',
headers={
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
)
if response.status_code == 200:
return response.json()
else:
error_data = response.json()
raise Exception(f"Failed to delete agent: {error_data['message']}")
# Usage with error handling
try:
result = delete_agent('agent_123')
print(f"Agent deleted: {result['message']}")
except Exception as e:
print(f"Delete failed: {e}")
```
## Error Handling
### Status Code Reference
| Status Code | Error Code | Description | Action |
| ----------- | --------------------- | ----------------------------------- | ----------------------------------------- |
| 200 | - | Success | Agent deleted successfully |
| 400 | `invalid_status` | Kakiyo-managed agent is not `ended` | End the agent, then retry |
| 403 | `forbidden` | No access to agent | Verify agent belongs to your team |
| 404 | `not_found` | Agent doesn't exist | Check agent ID is correct |
| 409 | `campaign_busy` | A campaign import is active | Wait for the import to finish, then retry |
| 429 | `rate_limit_exceeded` | Too many requests | Retry after the indicated delay |
| 500 | `internal_error` | Server error | Retry request or contact support |
### Comprehensive Error Handling
```javascript theme={null}
const safeDeleteAgent = async (agentId) => {
try {
const response = await fetch(`https://api.kakiyo.com/v1/agents/${agentId}`, {
method: 'DELETE',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
if (!response.ok) {
switch (data.error) {
case 'not_found':
throw new Error('Agent not found. Please check the agent ID.');
case 'forbidden':
throw new Error('You do not have permission to delete this agent.');
case 'campaign_busy':
throw new Error('Agent cannot be deleted while a campaign import is active. Retry shortly.');
case 'invalid_status':
throw new Error(`Agent cannot be deleted. Current status: ${data.currentStatus}.`);
case 'internal_error':
throw new Error('Server error occurred. Please try again later.');
default:
throw new Error(`Unexpected error: ${data.message}`);
}
}
return data;
} catch (error) {
console.error('Delete agent error:', error.message);
throw error;
}
};
```
## Integration Examples
### Safe Deletion Workflow
```javascript theme={null}
const safeAgentDeletion = async (agentId) => {
try {
// Confirm deletion (in a real app, this would be user confirmation)
const confirmed = true; // Replace with actual confirmation logic
if (!confirmed) {
return { success: false, reason: 'User cancelled' };
}
// Proceed with deletion
const result = await deleteAgent(agentId);
return {
success: true,
message: result.message
};
} catch (error) {
return {
success: false,
error: error.message
};
}
};
```
### Bulk Agent Cleanup
```javascript theme={null}
const cleanupAgents = async (agentIds) => {
try {
const results = [];
for (const agentId of agentIds) {
try {
await deleteAgent(agentId);
results.push({ id: agentId, success: true });
console.log(`✓ Deleted agent ${agentId}`);
} catch (error) {
results.push({ id: agentId, success: false, error: error.message });
console.log(`✗ Failed to delete agent ${agentId}: ${error.message}`);
}
}
return results;
} catch (error) {
console.error('Bulk cleanup failed:', error.message);
throw error;
}
};
```
## Best Practices
1. **Status Verification**: Ensure Kakiyo-managed agents are ended and campaign imports have completed before attempting deletion
2. **User Confirmation**: Implement confirmation dialogs for destructive operations
3. **Error Handling**: Handle all possible error scenarios gracefully
4. **Logging**: Log deletion operations for audit trails
5. **Backup Consideration**: Consider exporting important data before deletion
6. **Batch Operations**: Use rate limiting when deleting multiple agents
## Security Considerations
* **Authorization**: Ensure proper API key permissions
* **Team Isolation**: Agents can only be deleted by team members
* **Audit Logging**: All deletion operations are logged
* **Data Cleanup**: External resources are properly cleaned up
## What Gets Deleted
When an agent is deleted, the following data is permanently removed:
* **Agent Configuration**: All settings, credentials, and preferences
* **Usage Statistics**: Historical usage data and metrics
* **External Resources**: GoLogin profiles and proxy assignments
* **Task History**: All completed and pending tasks
* **Alert History**: All alerts and notifications
* **Integration Data**: Any connected third-party service data
This operation cannot be undone. Make sure you have exported any important data before proceeding with deletion.
# Get agent details
Source: https://docs.kakiyo.com/api-reference/agents/details
GET /agents/{id}
Returns details of a specific agent
# List agents
Source: https://docs.kakiyo.com/api-reference/agents/list
GET /agents
Returns all agents for the authenticated team
# Pause agent
Source: https://docs.kakiyo.com/api-reference/agents/pause
POST /agents/{id}/pause
Pauses an agent's activities
# Relaunch agent
Source: https://docs.kakiyo.com/api-reference/agents/relaunch
POST /agents/{id}/relaunch
## Overview
Relaunch an ended agent by resetting it to `setup_needed` status. This endpoint allows you to restart an agent that has ended, clearing its configuration and allowing it to be set up again from scratch. Unlike deletion, this preserves the agent entity while resetting its state.
## Prerequisites
* Agent must have status `ended`
* You must have access to the agent (same team)
* Agent must exist in your account
## Use Cases
* **Agent Recovery**: Restart agents that ended due to issues
* **Reconfiguration**: Reset agent to change LinkedIn credentials or country
* **Redeployment**: Restart agents with fresh configuration
* **Testing**: Reset agents for testing different configurations
## Path Parameters
The unique identifier of the agent to relaunch
## Response Examples
### Success Response
```json theme={null}
{
"message": "Agent relaunched successfully",
"status": "setup_needed"
}
```
### Error Responses
```json theme={null}
// Agent not found
{
"error": "not_found",
"message": "Agent not found"
}
// No access to agent
{
"error": "forbidden",
"message": "You do not have access to this agent"
}
// Invalid agent status
{
"error": "invalid_status",
"message": "Agent can only be relaunched when status is ended",
"currentStatus": "running"
}
// Internal server error
{
"error": "internal_error",
"message": "An internal error occurred"
}
```
## What Happens During Relaunch
When an agent is relaunched, the following changes occur:
* **Status Reset**: Agent status changes from `ended` to `setup_needed`
* **Configuration Cleared**: LinkedIn credentials and passwords are removed
* **External Resources**: GoLogin tokens and proxy assignments are cleared
* **Alerts Cleared**: All alerts and notifications are removed
* **Tasks Cleared**: Current tasks and actions are reset
* **Agent Preserved**: The agent entity and ID remain the same
## Testing Examples
```bash theme={null}
# Relaunch an ended agent
curl -X POST "https://api.kakiyo.com/v1/agents/agent_123/relaunch" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript theme={null}
// JavaScript/Node.js
const relaunchAgent = async (agentId) => {
const response = await fetch(`https://api.kakiyo.com/v1/agents/${agentId}/relaunch`, {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
if (!response.ok) {
const error = await response.json();
throw new Error(`Failed to relaunch agent: ${error.message}`);
}
return await response.json();
};
// Usage with error handling
try {
const result = await relaunchAgent('agent_123');
console.log('Agent relaunched:', result.message);
console.log('New status:', result.status);
} catch (error) {
console.error('Relaunch failed:', error.message);
}
```
```python theme={null}
# Python
import requests
def relaunch_agent(agent_id):
"""Relaunch an ended agent"""
response = requests.post(
f'https://api.kakiyo.com/v1/agents/{agent_id}/relaunch',
headers={
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
)
if response.status_code == 200:
return response.json()
else:
error_data = response.json()
raise Exception(f"Failed to relaunch agent: {error_data['message']}")
# Usage with error handling
try:
result = relaunch_agent('agent_123')
print(f"Agent relaunched: {result['message']}")
print(f"New status: {result['status']}")
except Exception as e:
print(f"Relaunch failed: {e}")
```
## Error Handling
### Status Code Reference
| Status Code | Error Code | Description | Action |
| ----------- | ---------------- | --------------------------- | ---------------------------------------- |
| 200 | - | Success | Agent relaunched successfully |
| 400 | `invalid_status` | Agent status is not 'ended' | Wait for agent to end or manually end it |
| 403 | `forbidden` | No access to agent | Verify agent belongs to your team |
| 404 | `not_found` | Agent doesn't exist | Check agent ID is correct |
| 500 | `internal_error` | Server error | Retry request or contact support |
### Comprehensive Error Handling
```javascript theme={null}
const safeRelaunchAgent = async (agentId) => {
try {
const response = await fetch(`https://api.kakiyo.com/v1/agents/${agentId}/relaunch`, {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
if (!response.ok) {
switch (data.error) {
case 'not_found':
throw new Error('Agent not found. Please check the agent ID.');
case 'forbidden':
throw new Error('You do not have permission to relaunch this agent.');
case 'invalid_status':
throw new Error(`Agent cannot be relaunched. Current status: ${data.currentStatus}. Agent must be ended first.`);
case 'internal_error':
throw new Error('Server error occurred. Please try again later.');
default:
throw new Error(`Unexpected error: ${data.message}`);
}
}
return data;
} catch (error) {
console.error('Relaunch agent error:', error.message);
throw error;
}
};
```
## Integration Examples
### Complete Relaunch Workflow
```javascript theme={null}
const completeAgentRelaunch = async (agentId, newConfig) => {
try {
// Step 1: Check agent status
const agent = await fetch(`https://api.kakiyo.com/v1/agents/${agentId}`, {
headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
}).then(r => r.json());
if (agent.status !== 'ended') {
throw new Error(`Agent status is ${agent.status}. Cannot relaunch until ended.`);
}
// Step 2: Relaunch agent
const relaunchResult = await relaunchAgent(agentId);
console.log('✓ Agent relaunched:', relaunchResult.message);
// Step 3: Setup agent with new configuration
const setupResult = await fetch(`https://api.kakiyo.com/v1/agents/${agentId}/setup`, {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify(newConfig)
}).then(r => r.json());
console.log('✓ Agent setup completed');
return {
success: true,
agentId: agentId,
status: 'setup_completed',
message: 'Agent successfully relaunched and configured'
};
} catch (error) {
return {
success: false,
error: error.message
};
}
};
// Usage
const newConfig = {
login: "new_linkedin_email@example.com",
password: "new_secure_password_456",
country: "FR"
};
const result = await completeAgentRelaunch('agent_123', newConfig);
console.log('Relaunch workflow result:', result);
```
### Bulk Agent Relaunch
```javascript theme={null}
const relaunchMultipleAgents = async (agentIds) => {
const results = [];
for (const agentId of agentIds) {
try {
const result = await relaunchAgent(agentId);
results.push({
agentId,
success: true,
status: result.status,
message: result.message
});
console.log(`✓ Relaunched agent ${agentId}`);
} catch (error) {
results.push({
agentId,
success: false,
error: error.message
});
console.log(`✗ Failed to relaunch agent ${agentId}: ${error.message}`);
}
}
return results;
};
// Usage
const agentIds = ['agent_123', 'agent_456', 'agent_789'];
const results = await relaunchMultipleAgents(agentIds);
const successful = results.filter(r => r.success).length;
const failed = results.filter(r => !r.success).length;
console.log(`Relaunch completed: ${successful} successful, ${failed} failed`);
```
### Agent Status Monitoring
```javascript theme={null}
const monitorAgentRelaunch = async (agentId) => {
try {
// Relaunch the agent
await relaunchAgent(agentId);
// Monitor status changes
const checkStatus = async () => {
const agent = await fetch(`https://api.kakiyo.com/v1/agents/${agentId}`, {
headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
}).then(r => r.json());
return agent.status;
};
console.log('Monitoring agent status after relaunch...');
let currentStatus = await checkStatus();
console.log(`Initial status: ${currentStatus}`);
// Check status every 30 seconds for up to 5 minutes
const maxChecks = 10;
let checks = 0;
while (checks < maxChecks && currentStatus === 'setup_needed') {
await new Promise(resolve => setTimeout(resolve, 30000)); // Wait 30 seconds
currentStatus = await checkStatus();
checks++;
console.log(`Status check ${checks}: ${currentStatus}`);
}
return {
finalStatus: currentStatus,
checksPerformed: checks
};
} catch (error) {
console.error('Monitoring failed:', error.message);
throw error;
}
};
```
## Best Practices
1. **Status Verification**: Always check agent status before relaunching
2. **Configuration Ready**: Have new configuration ready for immediate setup
3. **Error Handling**: Handle all possible error scenarios
4. **Monitoring**: Monitor agent status after relaunch
5. **Documentation**: Document why agents are being relaunched
6. **Rate Limiting**: Avoid relaunching too many agents simultaneously
## Next Steps After Relaunch
After successfully relaunching an agent:
1. **Setup Agent**: Use the `/agents/{id}/setup` endpoint to configure credentials
2. **Verify Configuration**: Check agent status and configuration
3. **Monitor Health**: Watch for any setup issues or alerts
4. **Test Functionality**: Verify the agent is working as expected
## Comparison: Relaunch vs Delete
| Aspect | Relaunch | Delete |
| ----------------- | ------------------- | ------------------- |
| **Agent Entity** | Preserved | Permanently removed |
| **Agent ID** | Remains same | Lost forever |
| **Usage History** | Preserved | Permanently deleted |
| **Configuration** | Reset to defaults | N/A |
| **Recovery** | Can be reconfigured | Cannot be recovered |
| **Use Case** | Temporary reset | Permanent cleanup |
Relaunch is ideal when you want to reconfigure an agent with different settings, while delete is for permanent removal when the agent is no longer needed.
# Resume agent
Source: https://docs.kakiyo.com/api-reference/agents/resume
POST /agents/{id}/resume
Resumes a paused agent
# Setup agent
Source: https://docs.kakiyo.com/api-reference/agents/setup
POST /agents/{id}/setup
Sets up an agent with LinkedIn credentials and location
# Update Agent Settings
Source: https://docs.kakiyo.com/api-reference/agents/update-settings
PUT /agents/{id}
Updates an agent's working hours and scheduling settings. Changes are applied immediately and the scheduler is re-triggered if the agent is running.
## Endpoint
```
PUT https://api.kakiyo.com/v1/agents/:agentId
```
## Path Parameters
| Parameter | Type | Required | Description |
| --------- | ------ | -------- | ---------------------- |
| `agentId` | string | Yes | The agent ID to update |
## Request Body
All sections are optional. You can update just one section or multiple at once.
### Working Hours
| Field | Type | Description |
| ------- | ------ | --------------------------------------------------------------------- |
| `days` | string | Working days (Mon-Sun). Format: `1:1:1:1:1:0:0` where 1=active, 0=off |
| `start` | string | Start time in HH:MM format (24-hour) |
| `stop` | string | End time in HH:MM format (24-hour) |
### Limits
| Field | Type | Description |
| ---------------- | ------- | --------------------------------- |
| `invitationsMin` | integer | Minimum daily invitations (1-100) |
| `invitationsMax` | integer | Maximum daily invitations (2-100) |
| `messagesMin` | integer | Minimum daily messages (1-500) |
| `messagesMax` | integer | Maximum daily messages (2-500) |
### Settings
Array of key-value pairs for behavior settings:
| Key | Type | Description |
| ----------------- | ------- | ----------------------------------------------------------------- |
| `skipInNetwork` | boolean | Don't send messages to prospects already in your LinkedIn network |
| `invitationsOnly` | boolean | Only send invitations, skip follow-up messages |
## Response
```json theme={null}
{
"id": "69724b7100331796aae2",
"message": "Agent settings updated successfully"
}
```
## Example Requests
### Update Working Hours Only
```bash theme={null}
curl -X PUT "https://api.kakiyo.com/v1/agents/69724b7100331796aae2" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"workingHours": {
"days": "1:1:1:1:1:0:0",
"start": "08:00",
"stop": "18:00"
}
}'
```
### Update Limits Only
```bash theme={null}
curl -X PUT "https://api.kakiyo.com/v1/agents/69724b7100331796aae2" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"limits": {
"invitationsMin": 20,
"invitationsMax": 30,
"messagesMin": 100,
"messagesMax": 150
}
}'
```
### Update Settings Only
```bash theme={null}
curl -X PUT "https://api.kakiyo.com/v1/agents/69724b7100331796aae2" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"settings": [
{ "key": "skipInNetwork", "value": true }
]
}'
```
### Update Everything
```bash theme={null}
curl -X PUT "https://api.kakiyo.com/v1/agents/69724b7100331796aae2" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"workingHours": {
"days": "1:1:1:1:1:0:0",
"start": "08:00",
"stop": "18:00"
},
"limits": {
"invitationsMin": 20,
"invitationsMax": 30,
"messagesMin": 100,
"messagesMax": 150
},
"settings": [
{ "key": "skipInNetwork", "value": true }
]
}'
```
## Working Days Format
The `days` parameter uses a colon-separated format representing Monday through Sunday:
| Position | Day |
| -------- | --------- |
| 1st | Monday |
| 2nd | Tuesday |
| 3rd | Wednesday |
| 4th | Thursday |
| 5th | Friday |
| 6th | Saturday |
| 7th | Sunday |
**Examples:**
* `1:1:1:1:1:0:0` - Monday to Friday
* `1:1:1:1:1:1:0` - Monday to Saturday
* `0:1:1:1:1:1:0` - Tuesday to Saturday
Changes are applied immediately. If the agent is running, the scheduler is automatically re-triggered with the new settings.
# Campaign Analytics
Source: https://docs.kakiyo.com/api-reference/analytics/campaigns
GET /analytics/campaigns/{campaignId}
Get detailed analytics for a specific campaign
## Overview
Get detailed analytics and performance metrics for a specific campaign. This endpoint provides comprehensive insights into campaign performance, prospect engagement, and conversion metrics.
## Path Parameters
The unique identifier of the campaign to analyze
## Use Cases
* **Campaign Performance Review**: Analyze individual campaign effectiveness
* **Optimization Insights**: Identify areas for campaign improvement
* **ROI Analysis**: Calculate return on investment for specific campaigns
* **A/B Testing**: Compare performance between different campaign strategies
## Response Structure
### Campaign Details
* Basic campaign information and configuration
* Current status and timeline
### Performance Metrics
* Prospect engagement statistics
* Message and response metrics
* Qualification and conversion rates
### Daily Activity Breakdown
* Day-by-day activity analysis
* Trend identification over time
### Status Distribution
* Breakdown of prospects by conversation status
* Qualification status analysis
## Example Response
```json theme={null}
{
"campaign": {
"id": "campaign_123",
"name": "Q4 Enterprise Outreach",
"status": "active",
"createdAt": "2024-01-15T10:30:00Z",
"agent": "agent_456",
"product": "Enterprise Solution"
},
"metrics": {
"totalProspects": 150,
"totalMessages": 420,
"totalQualified": 12,
"totalAnswers": 35,
"totalClosed": 8,
"conversionRate": 8.0,
"responseRate": 23.33,
"qualificationRate": 34.29,
"averageMessagesPerProspect": 2.8
},
"activity": {
"dailyBreakdown": [
{
"date": "2024-01-20",
"messages": 25,
"responses": 4,
"qualified": 1
},
{
"date": "2024-01-19",
"messages": 30,
"responses": 6,
"qualified": 2
}
],
"last7Days": {
"messages": 180,
"responses": 28,
"qualified": 8
}
},
"statusDistribution": {
"pending": 85,
"contacted": 45,
"responded": 35,
"qualified": 12,
"closed": 8
},
"qualificationBreakdown": {
"pending": 123,
"qualified": 12,
"disqualified": 15
}
}
```
## Testing Example
```bash theme={null}
curl -X GET "https://api.kakiyo.com/v1/analytics/campaigns/campaign_123" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript theme={null}
// JavaScript/Node.js
const campaignId = 'campaign_123';
const response = await fetch(`https://api.kakiyo.com/v1/analytics/campaigns/${campaignId}`, {
method: 'GET',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const analytics = await response.json();
console.log('Campaign Analytics:', analytics);
```
```python theme={null}
# Python
import requests
campaign_id = 'campaign_123'
response = requests.get(
f'https://api.kakiyo.com/v1/analytics/campaigns/{campaign_id}',
headers={
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
)
analytics = response.json()
print('Campaign Analytics:', analytics)
```
## Error Responses
### Campaign Not Found
```json theme={null}
{
"error": "not_found",
"message": "Campaign not found"
}
```
### Access Denied
```json theme={null}
{
"error": "forbidden",
"message": "You do not have access to this campaign"
}
```
## Analytics Insights
### Performance Indicators
**High-Performing Campaigns:**
* Response rate > 20%
* Qualification rate > 30%
* Conversion rate > 5%
**Optimization Opportunities:**
* Low response rate: Review messaging strategy
* High responses, low qualification: Improve targeting
* High qualification, low closing: Enhance follow-up process
### Daily Activity Patterns
Monitor daily breakdowns to identify:
* Peak engagement days
* Message volume optimization
* Response timing patterns
## Best Practices
1. **Regular Review**: Analyze campaign metrics weekly
2. **Comparative Analysis**: Compare with team averages
3. **Trend Monitoring**: Track performance changes over time
4. **Data-Driven Decisions**: Use metrics to guide campaign adjustments
# Analytics Overview
Source: https://docs.kakiyo.com/api-reference/analytics/overview
GET /analytics/overview
Get comprehensive analytics and performance metrics for your entire team
## Overview
Get comprehensive analytics and performance metrics for your entire team. This endpoint provides a complete dashboard view of all campaigns, agents, prospects, and key performance indicators.
## Use Cases
* **Dashboard Creation**: Build comprehensive analytics dashboards
* **Performance Monitoring**: Track team-wide performance metrics
* **Reporting**: Generate executive summaries and reports
* **Trend Analysis**: Monitor activity trends over time
## Response Structure
The response includes four main sections:
### Summary Statistics
* Total campaigns (active, paused, completed)
* Agent metrics (total and active agents)
* Prospect metrics (total, qualified, responses)
### Performance Metrics
* Conversion rates and response rates
* Average messages per prospect
* Qualification rates
### Activity Metrics
* 24-hour activity summary
* Weekly activity trends
### Campaign Breakdown
* Individual campaign performance
* Status distribution
## Example Response
```json theme={null}
{
"summary": {
"totalCampaigns": 15,
"activeCampaigns": 8,
"pausedCampaigns": 5,
"completedCampaigns": 2,
"totalAgents": 3,
"activeAgents": 2,
"totalProspects": 1250,
"totalMessages": 3420,
"totalQualified": 89,
"totalAnswers": 234,
"totalClosed": 45
},
"metrics": {
"conversionRate": 7.12,
"responseRate": 18.72,
"averageMessagesPerProspect": 2.74,
"qualificationRate": 38.03
},
"activity": {
"last24Hours": {
"messages": 45,
"qualified": 3
},
"lastWeek": {
"messages": 312,
"qualified": 18
}
},
"campaigns": [
{
"id": "campaign_123",
"name": "Q4 Enterprise Outreach",
"status": "active",
"prospects": 150,
"messages": 420,
"qualified": 12,
"answers": 35,
"conversionRate": 8.0,
"responseRate": 23.33
}
]
}
```
## Testing Example
```bash theme={null}
curl -X GET "https://api.kakiyo.com/v1/analytics/overview" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript theme={null}
// JavaScript/Node.js
const response = await fetch('https://api.kakiyo.com/v1/analytics/overview', {
method: 'GET',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const analytics = await response.json();
console.log('Team Analytics:', analytics);
```
```python theme={null}
# Python
import requests
response = requests.get(
'https://api.kakiyo.com/v1/analytics/overview',
headers={
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
)
analytics = response.json()
print('Team Analytics:', analytics)
```
## Key Metrics Explained
### Conversion Rate
Percentage of prospects that became qualified leads out of total prospects contacted.
### Response Rate
Percentage of prospects that responded to outreach messages.
### Qualification Rate
Percentage of responding prospects that were marked as qualified.
### Average Messages Per Prospect
Average number of messages sent per prospect across all campaigns.
## Best Practices
1. **Regular Monitoring**: Check analytics daily to identify trends
2. **Performance Comparison**: Compare metrics across different time periods
3. **Campaign Optimization**: Use data to optimize underperforming campaigns
4. **Resource Allocation**: Allocate agents based on performance metrics
# Verify API key
Source: https://docs.kakiyo.com/api-reference/auth/verify
GET /verify
Verifies that the provided API key is valid and returns information about the associated team
# Create Campaign
Source: https://docs.kakiyo.com/api-reference/campaigns/create
POST /campaigns
Creates a new outreach campaign
## Overview
Create a new LinkedIn outreach campaign with AI-powered automation. This endpoint sets up a complete campaign with specified products, prompts, and agents, ready to start prospecting.
## Use Cases
* **New Product Launch**: Create campaigns for new product introductions
* **Market Expansion**: Set up campaigns for new geographic markets
* **Seasonal Campaigns**: Launch time-sensitive promotional campaigns
* **A/B Testing**: Create multiple campaigns to test different approaches
* **Delayed Launch**: Create campaigns early (with `preventAutoStart: true`), upload leads, and launch later when ready
## Key Features
* **AI-Powered Messaging**: Automated message generation using specified prompts
* **Smart Qualification**: Automatic prospect qualification based on responses
* **Agent Assignment**: Dedicated LinkedIn agents for authentic outreach
* **Performance Tracking**: Built-in analytics and conversion tracking
* **Prevent Auto-Start**: Optionally keep campaigns paused through lead uploads until you manually resume
## Testing Example
```bash theme={null}
curl -X POST "https://api.kakiyo.com/v1/campaigns" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"name": "Q4 Enterprise Outreach",
"productId": "prod_123456789",
"promptId": "prompt_987654321",
"agentId": "agent_abcdef123456",
"variables": {
"company_name": "Your Company",
"value_proposition": "20% increase in sales efficiency"
}
}'
# Create a campaign that stays paused until manually resumed
curl -X POST "https://api.kakiyo.com/v1/campaigns" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"name": "Delayed Launch Campaign",
"productId": "prod_123456789",
"promptId": "prompt_987654321",
"agentId": "agent_abcdef123456",
"variables": {},
"preventAutoStart": true
}'
```
```javascript theme={null}
// JavaScript/Node.js
const createCampaign = async (campaignData) => {
const response = await fetch('https://api.kakiyo.com/v1/campaigns', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify(campaignData)
});
return await response.json();
};
// Usage example
// Create campaign (starts active immediately)
const newCampaign = await createCampaign({
name: 'Q4 Enterprise Outreach',
productId: 'prod_123456789',
promptId: 'prompt_987654321',
agentId: 'agent_abcdef123456',
variables: {
company_name: 'Your Company',
value_proposition: '20% increase in sales efficiency'
}
});
// Create campaign that stays paused until manually resumed
const delayedCampaign = await createCampaign({
name: 'Delayed Launch Campaign',
productId: 'prod_123456789',
promptId: 'prompt_987654321',
agentId: 'agent_abcdef123456',
variables: {},
preventAutoStart: true
});
console.log('Campaign Created:', newCampaign);
```
```python theme={null}
# Python
import requests
def create_campaign(campaign_data):
"""Create a new LinkedIn outreach campaign"""
response = requests.post(
'https://api.kakiyo.com/v1/campaigns',
json=campaign_data,
headers={
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
)
return response.json()
# Usage example
campaign_data = {
'name': 'Q4 Enterprise Outreach',
'productId': 'prod_123456789',
'promptId': 'prompt_987654321',
'agentId': 'agent_abcdef123456',
'variables': {
'company_name': 'Your Company',
'value_proposition': '20% increase in sales efficiency'
}
}
result = create_campaign(campaign_data)
print('Campaign Created:', result)
# Create campaign that stays paused until manually resumed
delayed_campaign = create_campaign({
'name': 'Delayed Launch Campaign',
'productId': 'prod_123456789',
'promptId': 'prompt_987654321',
'agentId': 'agent_abcdef123456',
'variables': {},
'preventAutoStart': True
})
print('Delayed Campaign:', delayed_campaign)
```
## Prevent Auto-Start
By default, campaigns become active immediately and start outreach as soon as leads are uploaded. If you need to build campaigns ahead of time and launch later:
1. Set `preventAutoStart: true` when creating the campaign
2. Upload your leads — the campaign stays paused
3. When ready, call `POST /campaigns/{id}/resume` to activate
Resuming also clears the `preventAutoStart` flag, so subsequent uploads behave normally.
## Best Practices
1. **Descriptive Names**: Use clear, descriptive campaign names
2. **Variable Planning**: Define all necessary variables before campaign creation
3. **Agent Capacity**: Ensure assigned agents have available capacity
4. **Testing**: Create test campaigns before launching to large prospect lists
5. **Delayed Launch**: Use `preventAutoStart: true` for campaigns you want to prepare in advance
## Next Steps
After creating a campaign:
1. **Add Prospects**: Use `/prospects` or `/prospects/batch` endpoints
2. **Monitor Performance**: Check campaign analytics regularly
3. **Optimize Settings**: Adjust qualification thresholds based on results
4. **Scale Gradually**: Start with smaller prospect lists and scale up
# Delete Campaign
Source: https://docs.kakiyo.com/api-reference/campaigns/delete
DELETE /campaigns/{id}
Permanently delete a campaign and all associated data
## Overview
Permanently delete a campaign and all associated data. This operation cascades to remove all related prospects, conversations, tasks, and analytics data. **This action cannot be undone.**
## Path Parameters
The unique identifier of the campaign to delete
## Use Cases
* **Campaign Cleanup**: Remove completed or obsolete campaigns
* **Data Management**: Clean up test campaigns and outdated data
* **Compliance**: Remove campaigns for data retention compliance
* **Resource Management**: Free up resources by removing unused campaigns
## Important Considerations
**Permanent Deletion**: This operation permanently deletes the campaign and ALL associated data including:
* All prospects in the campaign
* All conversation history and messages
* All tasks and scheduled activities
* All analytics and performance data
* All webhook events related to the campaign
This action cannot be undone. Consider exporting important data before deletion.
## Response Structure
The response provides a detailed summary of what was deleted:
```json theme={null}
{
"message": "Campaign deleted successfully",
"deletionSummary": {
"campaignId": "campaign_123",
"campaignName": "Q4 Enterprise Outreach",
"deletedItems": {
"prospects": 150,
"chats": 150,
"messages": 420,
"tasks": 75,
"webhookEvents": 12
},
"deletedAt": "2024-01-20T15:30:00Z"
}
}
```
## Testing Example
```bash theme={null}
curl -X DELETE "https://api.kakiyo.com/v1/campaigns/campaign_123" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript theme={null}
// JavaScript/Node.js
const campaignId = 'campaign_123';
const response = await fetch(`https://api.kakiyo.com/v1/campaigns/${campaignId}`, {
method: 'DELETE',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const result = await response.json();
console.log('Deletion Result:', result);
```
```python theme={null}
# Python
import requests
campaign_id = 'campaign_123'
response = requests.delete(
f'https://api.kakiyo.com/v1/campaigns/{campaign_id}',
headers={
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
)
result = response.json()
print('Deletion Result:', result)
```
## Error Responses
### Campaign Not Found
```json theme={null}
{
"error": "not_found",
"message": "Campaign not found"
}
```
### Access Denied
```json theme={null}
{
"error": "forbidden",
"message": "You do not have access to this campaign"
}
```
### Campaign In Use
```json theme={null}
{
"error": "campaign_active",
"message": "Cannot delete active campaign. Please pause the campaign first."
}
```
## Pre-Deletion Checklist
Before deleting a campaign, consider:
1. **Export Data**: Download important analytics and prospect data
2. **Pause Campaign**: Stop all active outreach activities
3. **Notify Team**: Inform team members about the deletion
4. **Backup Conversations**: Save important conversation history
5. **Update Integrations**: Remove campaign references from external systems
## Cascade Deletion Details
When a campaign is deleted, the following related data is automatically removed:
### Prospects
* All prospect records associated with the campaign
* Prospect profile information and additional fields
* LinkedIn profile data and enrichment information
### Conversations
* All chat records and conversation history
* Message threads and AI-generated content
* Response tracking and engagement metrics
### Tasks
* Scheduled outreach tasks
* Follow-up reminders and activities
* Automation workflows and triggers
### Analytics
* Campaign performance metrics
* Historical analytics data
* Activity logs and engagement tracking
### Webhooks
* Campaign-related webhook events
* Event history and delivery logs
## Best Practices
1. **Data Export**: Always export critical data before deletion
2. **Team Communication**: Notify relevant team members
3. **Gradual Cleanup**: Delete campaigns in batches for large cleanups
4. **Audit Trail**: Keep records of deleted campaigns for compliance
5. **Test Environment**: Practice deletion process in test environment first
## Recovery Options
**No Recovery Available**: Once a campaign is deleted, it cannot be recovered. The only way to restore functionality is to:
* Create a new campaign with similar settings
* Re-import prospect lists
* Reconfigure automation workflows
* Rebuild analytics from scratch
## Alternative Actions
Instead of deletion, consider these alternatives:
* **Pause Campaign**: Temporarily stop activities while preserving data
* **Archive Campaign**: Mark as inactive but keep data accessible
* **Export & Recreate**: Export data, delete, then recreate with improvements
# List campaigns
Source: https://docs.kakiyo.com/api-reference/campaigns/list
GET /campaigns
Returns all campaigns for the authenticated team
## Overview
List campaigns for the authenticated team.
This endpoint returns a plain array of campaigns.
## Backward Compatibility
* Default behavior remains unchanged: `GET /v1/campaigns` returns a plain array of campaigns.
* Existing integrations do not need to change anything.
## Optional Pagination Params
* `limit` is optional.
* If both pagination params are omitted, the endpoint returns the full list.
* If either pagination param is provided, pagination mode is used.
* Default `offset`: `0`
* Maximum: `100`
* Response shape does not change.
## Examples
Legacy full-list request:
```bash theme={null}
curl -X GET "https://api.kakiyo.com/v1/campaigns" \
-H "Authorization: Bearer YOUR_API_KEY"
```
With an explicit limit:
```bash theme={null}
curl -X GET "https://api.kakiyo.com/v1/campaigns?limit=50" \
-H "Authorization: Bearer YOUR_API_KEY"
```
With limit and offset:
```bash theme={null}
curl -X GET "https://api.kakiyo.com/v1/campaigns?limit=25&offset=25" \
-H "Authorization: Bearer YOUR_API_KEY"
```
Legacy response:
```json theme={null}
[
{
"id": "campaign_123",
"name": "Q4 Enterprise Outreach",
"status": "active",
"agent": "agent_123",
"product": "product_123",
"createdAt": "2026-03-01T12:00:00.000Z",
"stats": {
"prospects": 120,
"pendingInvitations": 83,
"prospectsAnswers": 14,
"messages": 38,
"qualified": 3,
"closed": 0
}
}
]
```
# Pause campaign
Source: https://docs.kakiyo.com/api-reference/campaigns/pause
POST /campaigns/{id}/pause
Pauses an active campaign
# Resume campaign
Source: https://docs.kakiyo.com/api-reference/campaigns/resume
POST /campaigns/{id}/resume
Resumes a paused campaign. If the campaign was created with `preventAutoStart: true`, resuming will also clear this flag so future uploads behave normally.
## Overview
Resumes a paused campaign. If the campaign was created with `preventAutoStart: true`, resuming will also clear this flag so future lead uploads auto-activate the campaign normally.
# Get campaign stats
Source: https://docs.kakiyo.com/api-reference/campaigns/stats
GET /campaigns/{id}/stats
Returns statistics for a specific campaign
# Update campaign
Source: https://docs.kakiyo.com/api-reference/campaigns/update
PUT /campaigns/{id}
Updates an existing campaign
# Add batch DNC entries
Source: https://docs.kakiyo.com/api-reference/dnc/add-batch
POST /dnc/batch
Bulk import multiple LinkedIn URLs to your team's Do Not Contact list
## Overview
Bulk import multiple LinkedIn URLs to your team's Do Not Contact (DNC) list in a single operation. This endpoint efficiently processes large lists of opt-outs, providing detailed reports on successes, duplicates, and errors.
## Use Cases
* **CSV Import**: Bulk import DNC lists from CSV files or spreadsheets
* **CRM Sync**: Synchronize opt-outs from external CRM systems
* **Compliance Migration**: Import historical opt-out lists from legacy systems
* **Mass Opt-Outs**: Process multiple opt-out requests simultaneously
* **System Integration**: Batch sync DNC entries from other platforms
## Key Features
* **Bulk Processing**: Add hundreds of URLs in a single request
* **Duplicate Handling**: Automatically skips existing entries without errors
* **Error Resilience**: Continues processing even if individual URLs fail
* **Detailed Reporting**: Returns comprehensive stats (added, duplicates, errors)
* **Automatic Normalization**: All URLs standardized before storage
* **Rate Limited**: 10 requests per minute for bulk operations
* **Team Isolation**: All entries scoped to your team
## Testing Example
```bash theme={null}
curl -X POST "https://api.kakiyo.com/v1/dnc/batch" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"entries": [
{
"url": "https://linkedin.com/in/johnsmith"
},
{
"url": "https://linkedin.com/in/sarahjohnson"
},
{
"url": "https://linkedin.com/in/michaelchen"
}
]
}'
```
```javascript theme={null}
// JavaScript/Node.js
const bulkAddToDNC = async (linkedinUrls) => {
const response = await fetch('https://api.kakiyo.com/v1/dnc/batch', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
entries: linkedinUrls.map(url => ({ url }))
})
});
return await response.json();
};
// Usage example
const urls = [
'https://linkedin.com/in/john',
'https://linkedin.com/in/jane',
'https://linkedin.com/in/bob'
];
const result = await bulkAddToDNC(urls);
console.log(`✅ Added: ${result.data.added}`);
console.log(`⚠️ Duplicates: ${result.data.duplicates}`);
console.log(`❌ Errors: ${result.data.errors}`);
console.log('Details:', result.data.details);
```
```python theme={null}
# Python
import requests
def bulk_add_to_dnc(linkedin_urls):
"""Bulk add LinkedIn URLs to the DNC list"""
response = requests.post(
'https://api.kakiyo.com/v1/dnc/batch',
json={
'entries': [{'url': url} for url in linkedin_urls]
},
headers={
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
)
return response.json()
# Usage example
urls = [
'https://linkedin.com/in/john',
'https://linkedin.com/in/jane',
'https://linkedin.com/in/bob'
]
result = bulk_add_to_dnc(urls)
print(f"✅ Added: {result['data']['added']}")
print(f"⚠️ Duplicates: {result['data']['duplicates']}")
print(f"❌ Errors: {result['data']['errors']}")
print('Details:', result['data']['details'])
```
## Request Body
### Required Fields
| Field | Type | Required | Description |
| --------- | --------------- | -------- | ----------------------------------------------- |
| `entries` | `array