Check DNC status

curl -X GET "https://api.kakiyo.com/v1/dnc/check?url=https://linkedin.com/in/johnsmith" \
  -H "Authorization: Bearer YOUR_API_KEY"

// JavaScript/Node.js
const checkDNCStatus = async (linkedinUrl) => {
  const response = await fetch(
    `https://api.kakiyo.com/v1/dnc/check?url=${encodeURIComponent(linkedinUrl)}`,
    {
      method: 'GET',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    }
  );

  return await response.json();
};

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

if (status.data.onList) {
  console.log('⚠️ Contact is on DNC list');
  console.log('Entry:', status.data.entry);
} else {
  console.log('✅ Contact is NOT on DNC list');
}

# Python
import requests
from urllib.parse import quote

def check_dnc_status(linkedin_url):
    """Check if a LinkedIn URL is on the DNC list"""
    encoded_url = quote(linkedin_url, safe='')
    response = requests.get(
        f'https://api.kakiyo.com/v1/dnc/check?url={encoded_url}',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY'
        }
    )

    return response.json()

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

if result['data']['onList']:
    print('⚠️ Contact is on DNC list')
    print('Entry:', result['data']['entry'])
else:
    print('✅ Contact is NOT on DNC list')

{
  "error": null,
  "data": {
    "onList": true,
    "entry": {
      "$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"
    }
  }
}

{
  "error": null,
  "data": {
    "onList": false,
    "entry": null
  }
}

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

{
  "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"
}

// First check - hits database (slower)
const check1 = await checkDNCStatus('linkedin.com/in/john');
// Response time: ~100ms

// Second check within 5 minutes - hits cache (faster)
const check2 = await checkDNCStatus('linkedin.com/in/john');
// Response time: ~10ms

// After 5 minutes - hits database again
// OR if URL is added/removed from DNC list - cache invalidated

const validateProspectsBeforeImport = async (prospects) => {
  const validationResults = [];

  for (const prospect of prospects) {
    const dncStatus = await checkDNCStatus(prospect.linkedinUrl);

    validationResults.push({
      name: prospect.name,
      url: prospect.linkedinUrl,
      onDNC: dncStatus.data.onList,
      canImport: !dncStatus.data.onList
    });

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

  return validationResults;
};

// Usage
const prospects = [
  { name: 'John Smith', linkedinUrl: 'linkedin.com/in/john' },
  { name: 'Jane Doe', linkedinUrl: 'linkedin.com/in/jane' }
];

const validation = await validateProspectsBeforeImport(prospects);
const canImport = validation.filter(v => v.canImport);

console.log(`${canImport.length} of ${prospects.length} can be imported`);

const filterCampaignProspects = async (campaignProspects) => {
  const filtered = [];

  for (const prospect of campaignProspects) {
    const status = await checkDNCStatus(prospect.linkedinUrl);

    if (!status.data.onList) {
      filtered.push(prospect);
    } else {
      console.log(`Skipping ${prospect.name} - on DNC list`);
    }
  }

  return filtered;
};

const batchCheckDNC = async (urls) => {
  // Group URLs to check
  const results = [];

  // Process in batches to respect rate limits
  const batchSize = 50; // 50 per minute to stay under 60/min limit

  for (let i = 0; i < urls.length; i += batchSize) {
    const batch = urls.slice(i, i + batchSize);

    const batchResults = await Promise.all(
      batch.map(async (url) => {
        const status = await checkDNCStatus(url);
        return {
          url,
          onDNC: status.data.onList,
          entry: status.data.entry
        };
      })
    );

    results.push(...batchResults);

    // Wait before next batch if needed
    if (i + batchSize < urls.length) {
      await new Promise(resolve => setTimeout(resolve, 60000));
    }
  }

  return results;
};

const validateCRMContact = async (contact) => {
  if (!contact.linkedinUrl) {
    return { valid: false, reason: 'No LinkedIn URL' };
  }

  const dncStatus = await checkDNCStatus(contact.linkedinUrl);

  if (dncStatus.data.onList) {
    return {
      valid: false,
      reason: 'On DNC list',
      dncEntry: dncStatus.data.entry
    };
  }

  return { valid: true };
};

// Usage
const contact = {
  name: 'John Smith',
  linkedinUrl: 'linkedin.com/in/john'
};

const validation = await validateCRMContact(contact);

if (validation.valid) {
  await crmClient.addToCampaign(contact);
} else {
  console.log(`Cannot add ${contact.name}: ${validation.reason}`);
}

const runComplianceCheck = async (prospectList) => {
  const report = {
    total: prospectList.length,
    onDNC: 0,
    safe: 0,
    violations: []
  };

  for (const prospect of prospectList) {
    const status = await checkDNCStatus(prospect.linkedinUrl);

    if (status.data.onList) {
      report.onDNC++;
      report.violations.push({
        name: prospect.name,
        url: prospect.linkedinUrl,
        addedToDNC: status.data.entry.$createdAt
      });
    } else {
      report.safe++;
    }
  }

  return report;
};

const validateCampaignProspects = async (campaignId) => {
  const prospects = await getProspectsForCampaign(campaignId);

  const validation = await Promise.all(
    prospects.map(async (p) => {
      const status = await checkDNCStatus(p.linkedinUrl);
      return {
        prospectId: p.id,
        name: p.name,
        blocked: status.data.onList
      };
    })
  );

  const blocked = validation.filter(v => v.blocked);

  if (blocked.length > 0) {
    console.log(`⚠️ ${blocked.length} prospects are on DNC list`);
    return { canLaunch: false, blocked };
  }

  return { canLaunch: true, blocked: [] };
};

const importWizardStep = async (csvData) => {
  const validation = {
    valid: [],
    invalid: [],
    onDNC: []
  };

  for (const row of csvData) {
    if (!row.linkedinUrl) {
      validation.invalid.push({ ...row, reason: 'Missing URL' });
      continue;
    }

    const dncStatus = await checkDNCStatus(row.linkedinUrl);

    if (dncStatus.data.onList) {
      validation.onDNC.push({
        ...row,
        dncEntry: dncStatus.data.entry
      });
    } else {
      validation.valid.push(row);
    }
  }

  return validation;
};