Add single DNC entry

curl -X POST "https://api.kakiyo.com/v1/dnc" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://linkedin.com/in/johnsmith"
  }'

// JavaScript/Node.js
const addToDNC = async (linkedinUrl) => {
  const response = await fetch('https://api.kakiyo.com/v1/dnc', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      url: linkedinUrl
    })
  });

  return await response.json();
};

// Usage example
const result = await addToDNC('https://linkedin.com/in/johnsmith');

if (result.error) {
  console.log('❌ Failed to add:', result.error);
} else {
  console.log('✅ Added to DNC list:', result.data);
}

# Python
import requests

def add_to_dnc(linkedin_url):
    """Add a LinkedIn URL to the DNC list"""
    response = requests.post(
        'https://api.kakiyo.com/v1/dnc',
        json={'url': linkedin_url},
        headers={
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
        }
    )

    return response.json()

# Usage example
result = add_to_dnc('https://linkedin.com/in/johnsmith')

if result['error']:
    print('❌ Failed to add:', result['error'])
else:
    print('✅ Added to DNC list:', result['data'])

{
  "url": "https://linkedin.com/in/johnsmith"
}

{
  "error": null,
  "data": {
    "$id": "dnc_12345abcde",
    "teamId": "team_67890fghij",
    "url": "https://linkedin.com/in/johnsmith",
    "$createdAt": "2025-11-18T10:30:00.000Z",
    "$updatedAt": "2025-11-18T10:30:00.000Z"
  },
  "message": "Added to Do Not Contact list"
}

{
  "error": "dnc_entry_exists",
  "message": "URL already on DNC list"
}

{
  "error": "invalid_request",
  "message": "LinkedIn URL is required"
}

{
  "error": "invalid_url",
  "message": "Invalid LinkedIn URL format"
}

{
  "error": "rate_limit_exceeded",
  "message": "Too many requests. Please try again later.",
  "resetTime": 1700308800000
}

{
  "error": "unauthorized",
  "message": "Invalid or missing API key"
}

{
  "error": "internal_error",
  "message": "An internal error occurred"
}

const handleOptOutRequest = async (linkedinUrl, reason) => {
  try {
    // Add to DNC list
    const result = await addToDNC(linkedinUrl);

    if (result.error === 'dnc_entry_exists') {
      console.log('Already on DNC list');
      return { success: true, alreadyExists: true };
    }

    if (result.error) {
      console.error('Failed to add to DNC:', result.error);
      return { success: false, error: result.error };
    }

    // Log the opt-out
    await logOptOut({
      url: linkedinUrl,
      reason: reason,
      timestamp: new Date().toISOString(),
      dncId: result.data.$id
    });

    // Notify team
    await notifyTeam(`Contact opted out: ${linkedinUrl}`);

    return { success: true, entry: result.data };

  } catch (error) {
    console.error('Error handling opt-out:', error);
    return { success: false, error: error.message };
  }
};

// Usage
await handleOptOutRequest(
  'linkedin.com/in/john',
  'User replied with STOP'
);

const handleWebhookOptOut = async (webhookPayload) => {
  const { contact, source } = webhookPayload;

  // Validate payload
  if (!contact.linkedinUrl) {
    throw new Error('LinkedIn URL missing in webhook payload');
  }

  // Add to DNC
  const result = await addToDNC(contact.linkedinUrl);

  if (result.error && result.error !== 'dnc_entry_exists') {
    throw new Error(`Failed to add to DNC: ${result.error}`);
  }

  // Log the source
  await auditLog({
    action: 'dnc_added',
    source: source,
    contact: contact.linkedinUrl,
    timestamp: new Date().toISOString()
  });

  return result;
};

const syncCRMOptOuts = async (crmClient) => {
  // Get opt-outs from CRM
  const optOuts = await crmClient.getOptOuts({
    since: getLastSyncTime()
  });

  const results = {
    added: 0,
    alreadyExists: 0,
    failed: 0,
    errors: []
  };

  for (const optOut of optOuts) {
    try {
      const result = await addToDNC(optOut.linkedinUrl);

      if (result.error === 'dnc_entry_exists') {
        results.alreadyExists++;
      } else if (result.error) {
        results.failed++;
        results.errors.push({
          url: optOut.linkedinUrl,
          error: result.error
        });
      } else {
        results.added++;
      }

      // Rate limit protection
      await new Promise(resolve => setTimeout(resolve, 2000));

    } catch (error) {
      results.failed++;
      results.errors.push({
        url: optOut.linkedinUrl,
        error: error.message
      });
    }
  }

  // Update sync timestamp
  await updateLastSyncTime(new Date().toISOString());

  return results;
};

const handleUnsubscribeForm = async (formData) => {
  const { linkedinUrl, email, reason } = formData;

  // Validate input
  if (!linkedinUrl) {
    return {
      success: false,
      message: 'LinkedIn URL is required'
    };
  }

  // Add to DNC
  const result = await addToDNC(linkedinUrl);

  if (result.error === 'dnc_entry_exists') {
    return {
      success: true,
      message: 'You have already been removed from our contact list'
    };
  }

  if (result.error) {
    return {
      success: false,
      message: 'An error occurred. Please try again later.'
    };
  }

  // Send confirmation email
  if (email) {
    await sendEmail({
      to: email,
      subject: 'Unsubscribe Confirmation',
      body: `You have been removed from our contact list.`
    });
  }

  return {
    success: true,
    message: 'You have been successfully removed from our contact list'
  };
};

const monitorCampaignResponses = async (campaignId) => {
  // Get campaign responses
  const responses = await getCampaignResponses(campaignId);

  // Check for opt-out keywords
  const optOutKeywords = ['stop', 'unsubscribe', 'remove', 'opt out'];

  for (const response of responses) {
    const message = response.message.toLowerCase();

    // Check if response contains opt-out keywords
    const hasOptOut = optOutKeywords.some(keyword =>
      message.includes(keyword)
    );

    if (hasOptOut) {
      // Add to DNC
      await addToDNC(response.prospect.linkedinUrl);

      // Pause prospect in campaign
      await pauseProspect(campaignId, response.prospect.id);

      // Notify team
      await notifyTeam({
        type: 'opt_out_detected',
        prospect: response.prospect.name,
        campaign: campaignId,
        message: response.message
      });
    }
  }
};

const processOptOut = async (prospectId, linkedinUrl) => {
  // 1. Add to DNC list
  const dncResult = await addToDNC(linkedinUrl);

  if (dncResult.error && dncResult.error !== 'dnc_entry_exists') {
    throw new Error(`Failed to add to DNC: ${dncResult.error}`);
  }

  // 2. Pause in all campaigns
  await pauseProspectInAllCampaigns(prospectId);

  // 3. Log the action
  await auditLog({
    action: 'opt_out_processed',
    prospectId: prospectId,
    url: linkedinUrl,
    timestamp: new Date().toISOString()
  });

  // 4. Send confirmation
  return {
    success: true,
    message: 'Opt-out processed successfully',
    dncId: dncResult.data.$id
  };
};

const addToComplianceDashboard = async (linkedinUrl, reason) => {
  // Add to DNC
  const result = await addToDNC(linkedinUrl);

  // Update compliance metrics
  await updateMetrics({
    type: 'dnc_addition',
    timestamp: new Date().toISOString(),
    reason: reason,
    successful: !result.error
  });

  return result;
};