Getting Started with Ledly

Welcome to Ledly! This comprehensive guide will walk you through setting up your account and submitting your first lead in minutes.

What is Ledly?

Ledly is a lead management platform designed specifically for higher education institutions. It helps you:

• Capture leads from multiple sources (web forms, vendors, APIs)
• Validate and enrich lead data automatically using configurable rules
• Deduplicate leads to maintain clean data
• Route leads to the right programs and representatives
• Sync with your CRM (Salesforce, HubSpot, and more)
• Track attribution and measure marketing ROI

Quick Start: 5-Minute Setup

Follow these steps to get started with Ledly:

vk_test_abc123def456...  (Sandbox)
vk_live_abc123def456...  (Production)

curl -X POST https://sandbox.api.ledly.io/api/leads/inbound \
  -H "Authorization: Bearer vk_test_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "[email protected]",
    "first_name": "John",
    "last_name": "Doe",
    "phone": "+1-555-123-4567",
    "program_interest": "MBA Online",
    "source": "website",
    "utm_source": "google",
    "utm_medium": "cpc",
    "utm_campaign": "spring-enrollment-2025"
  }'

const response = await fetch('https://sandbox.api.ledly.io/api/leads/inbound', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer vk_test_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    email: '[email protected]',
    first_name: 'John',
    last_name: 'Doe',
    phone: '+1-555-123-4567',
    program_interest: 'MBA Online',
    source: 'website',
    utm_source: 'google',
    utm_medium: 'cpc',
    utm_campaign: 'spring-enrollment-2025'
  }),
});
 
const result = await response.json();
console.log('Lead submitted:', result.lead_id);

import requests
 
response = requests.post(
    'https://sandbox.api.ledly.io/api/leads/inbound',
    headers={
        'Authorization': 'Bearer vk_test_your_api_key',
        'Content-Type': 'application/json',
    },
    json={
        'email': '[email protected]',
        'first_name': 'John',
        'last_name': 'Doe',
        'phone': '+1-555-123-4567',
        'program_interest': 'MBA Online',
        'source': 'website',
        'utm_source': 'google',
        'utm_medium': 'cpc',
        'utm_campaign': 'spring-enrollment-2025'
    }
)
 
result = response.json()
print(f"Lead submitted: {result['lead_id']}")

<?php
$ch = curl_init('https://sandbox.api.ledly.io/api/leads/inbound');
 
$data = [
    'email' => '[email protected]',
    'first_name' => 'John',
    'last_name' => 'Doe',
    'phone' => '+1-555-123-4567',
    'program_interest' => 'MBA Online',
    'source' => 'website',
    'utm_source' => 'google',
    'utm_medium' => 'cpc',
    'utm_campaign' => 'spring-enrollment-2025'
];
 
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer vk_test_your_api_key',
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => json_encode($data)
]);
 
$response = curl_exec($ch);
$result = json_decode($response, true);
echo "Lead submitted: " . $result['lead_id'];

{
  "success": true,
  "lead_id": "lead_abc123xyz",
  "message": "Lead accepted",
  "timestamp": "2024-12-25T10:30:00Z"
}

Understanding Lead Processing

When a lead enters Ledly, it goes through a multi-stage processing pipeline:

Lead Received → Validation → Deduplication → Enrichment → Routing → CRM Sync → Webhooks

1. Validation

Leads are validated against your configured rules:

• Email format: Must be valid RFC 5322 format
• Email domain: Must have valid MX records
• Phone format: Normalized to E.164 format
• Required fields: Configurable per organization
• Disposable emails: Blocked by default (configurable)

Example Validation:

// Valid lead
{
  "email": "[email protected]",
  "phone": "+15551234567"
}
 
// Invalid lead (rejected)
{
  "email": "not-an-email",
  "phone": "invalid"
}
// Error: VALIDATION_ERROR

2. Deduplication

The system checks for duplicate leads using configurable matching criteria:

• Email matching: Exact match
• Phone matching: Normalized phone numbers
• Name similarity: Fuzzy matching (configurable threshold)

Deduplication Actions:

• Reject: Block duplicate and return error
• Merge: Update existing lead with new data
• Flag: Create but mark as potential duplicate
• Allow: Create anyway (useful for some use cases)

3. Enrichment

Your enrichment rules are applied in priority order:

Common Enrichment Rules:

• Set default field values
• Assign program codes
• Route to teams/reps
• Calculate derived fields
• Transform data (uppercase, lowercase, etc.)
• Lookup values from tables

Example Rule:

Condition: program_interest contains "MBA"
Actions:
  - Set program_code = "MBA-ONLINE"
  - Set assigned_team = "[email protected]"
  - Set region = "West Coast" (if state = "California")

4. Routing

Leads are routed based on your routing rules:

• Program assignment: Route to specific programs
• Rep assignment: Assign to specific representatives
• Team distribution: Round-robin or load-balanced
• Geographic routing: Based on state/region

5. CRM Sync

Finally, leads are synced to your connected CRM:

• Salesforce: Create Lead or Contact
• HubSpot: Create Contact
• Custom CRM: Via webhooks
• Field mapping: Configurable in Settings
• Retry logic: Automatic retries on failure

6. Webhooks

Webhooks notify your systems of events:

• lead.created - New lead received
• lead.validated - Lead passed validation
• lead.crm_synced - Lead synced to CRM
• lead.rejected - Lead rejected by rules

Setting Up Your Programs

Programs are the academic offerings you want to track leads for.

Configuring Lead Sources

Lead sources help you track where leads come from.

Built-in Sources

Ledly tracks these automatically:

• API submissions: Via vendor API
• Web forms: Direct submissions
• Imports: Bulk CSV imports
• Manual entry: Dashboard entry

Custom Sources

Create custom source identifiers:

{
  "source": "landing-page-mba",
  "utm_source": "google",
  "utm_medium": "cpc",
  "utm_campaign": "spring-2025-mba"
}

Best Practices:

• Use descriptive source names
• Include UTM parameters for attribution
• Track landing page URLs
• Capture referrer information

Connecting Your CRM

Sync leads automatically to your CRM.

Salesforce Integration

Other CRMs

Ledly supports:

• HubSpot: Native integration
• Zoho CRM: Native integration
• Custom CRM: Via webhooks
• Pipedrive: Via webhooks
• ActiveCampaign: Via webhooks

See CRM Integrations for detailed setup guides.

Setting Up Validation Rules

Control which leads are accepted.

Email Validation

Settings → Validation → Email

Configure:

• Format validation: Enabled (recommended)
• MX record check: Enabled (recommended)
• Disposable email blocking: Enabled/Disabled
• Custom blocked domains: Add domains to block

Example Blocked Domains:

mailinator.com
tempmail.com
guerrillamail.com
10minutemail.com

Phone Validation

Settings → Validation → Phone

Configure:

• Format validation: Enabled
• Country restrictions: Specific countries only
• Mobile only: Block landlines (optional)

Required Fields

Settings → Validation → Required Fields

Mark fields as required:

• ✅ Email (always required)
• ✅ First Name
• ✅ Last Name
• ⬜ Phone
• ⬜ Program Interest
• ✅ UTM Source (for paid campaigns)

Creating Enrichment Rules

Automate lead processing with rules.

Example: Set Default Source

Goal: Set source to “website” if empty.

Priority: 100
Condition: source is empty
Action: Set field "source" to "website"

Example: Route MBA Leads

Goal: Auto-assign MBA leads to MBA team.

Priority: 50
Condition: program_interest contains "MBA"
Actions:
  - Set field "program_code" to "MBA-ONLINE"
  - Set field "assigned_rep" to "[email protected]"
  - Set field "department" to "Business School"

Example: Reject Bots

Goal: Block leads with honeypot field filled.

Priority: 10 (high priority - reject early)
Condition: honeypot_field is not empty
Action: Reject lead with reason "Bot submission detected"

See Enrichment Rules for advanced examples.

Configuring Webhooks

Receive real-time notifications.

// Express.js example
app.post('/webhooks/ledly', express.json(), (req, res) => {
  const event = req.body;
 
  console.log(`Received: ${event.event}`);
 
  // Process event
  switch (event.event) {
    case 'lead.created':
      handleNewLead(event.data.lead);
      break;
    case 'lead.crm_synced':
      handleCrmSync(event.data);
      break;
  }
 
  res.status(200).send('OK');
});

See Webhooks Guide for security and best practices.

Inviting Team Members

Collaborate with your team.

User Roles

Invite Users

1. Go to Settings → Team
2. Click Invite User
3. Enter email and select role
4. Click Send Invitation

Users receive an email with setup instructions.

Going Live Checklist

Before moving to production:

1. Test Thoroughly in Sandbox

• ✅ Submit valid leads
• ✅ Test validation (submit invalid data)
• ✅ Test deduplication (submit same lead twice)
• ✅ Test enrichment rules
• ✅ Test CRM sync
• ✅ Test webhooks
• ✅ Test error handling

2. Configure Production Settings

• ✅ Create production API keys (vk_live_...)
• ✅ Configure validation rules
• ✅ Set up enrichment rules
• ✅ Connect production CRM
• ✅ Configure webhooks

3. Set Up Monitoring

• ✅ Configure webhook alerts
• ✅ Set up email notifications
• ✅ Monitor lead acceptance rates
• ✅ Track CRM sync status

4. Update Integration

• ✅ Switch from sandbox to production API
• ✅ Update API keys in your application
• ✅ Test with real traffic (small batch)
• ✅ Monitor for errors

5. Documentation

• ✅ Document your integration
• ✅ Train team on Ledly dashboard
• ✅ Create runbooks for common issues
• ✅ Set up support contacts

Common Integration Patterns

Web Form Integration

Capture leads from your website forms:

<form id="leadForm">
  <input type="email" name="email" required>
  <input type="text" name="first_name" required>
  <input type="text" name="last_name" required>
  <input type="tel" name="phone">
  <select name="program_interest">
    <option>MBA Online</option>
    <option>Nursing (BSN)</option>
    <option>Computer Science (MS)</option>
  </select>
  <button type="submit">Submit</button>
</form>
 
<script>
document.getElementById('leadForm').addEventListener('submit', async (e) => {
  e.preventDefault();
 
  const formData = new FormData(e.target);
  const leadData = Object.fromEntries(formData);
 
  // Add UTM parameters from URL
  const urlParams = new URLSearchParams(window.location.search);
  leadData.utm_source = urlParams.get('utm_source');
  leadData.utm_medium = urlParams.get('utm_medium');
  leadData.utm_campaign = urlParams.get('utm_campaign');
 
  // Add tracking data
  leadData.landing_page = window.location.href;
  leadData.referrer = document.referrer;
  leadData.ip_address = await fetch('https://api.ipify.org').then(r => r.text());
 
  // Submit to Ledly
  const response = await fetch('https://api.ledly.io/api/leads/inbound', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer vk_live_your_api_key',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(leadData)
  });
 
  if (response.ok) {
    window.location.href = '/thank-you';
  } else {
    alert('Submission failed. Please try again.');
  }
});
</script>

Backend Proxy Pattern

For production, proxy through your backend:

// Backend (Node.js/Express)
app.post('/api/submit-lead', async (req, res) => {
  try {
    const response = await fetch('https://api.ledly.io/api/leads/inbound', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.LEDLY_API_KEY}`, // Secure!
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(req.body)
    });
 
    const result = await response.json();
    res.json(result);
  } catch (error) {
    res.status(500).json({ error: 'Submission failed' });
  }
});
 
// Frontend
fetch('/api/submit-lead', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(leadData)
});

Lead Vendor Integration

If you purchase leads from vendors:

// Receive lead from vendor webhook
app.post('/vendor-webhook', async (req, res) => {
  const vendorLead = req.body;
 
  // Transform to Ledly format
  const ledlyLead = {
    email: vendorLead.email_address,
    first_name: vendorLead.fname,
    last_name: vendorLead.lname,
    phone: vendorLead.phone_number,
    program_interest: vendorLead.program,
    source: 'vendor-xyz',
    custom_fields: {
      vendor_lead_id: vendorLead.id,
      vendor_received_at: new Date().toISOString()
    }
  };
 
  // Submit to Ledly
  await fetch('https://api.ledly.io/api/leads/inbound', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.LEDLY_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(ledlyLead)
  });
 
  res.status(200).send('OK');
});

Next Steps

Getting Help

Documentation

• API Reference - Complete API docs
• Feature Guides - Detailed feature documentation
• Integration Guides - CRM and webhook setup

Support

• Email: [email protected]
• Response Time: < 24 hours
• Emergency: [email protected] (mark as urgent)

Community

• Slack Community: Join here
• GitHub Discussions: Share integrations and best practices
• Monthly Webinars: Live Q&A and feature demos

Tips for Success

1. Start with Sandbox - Test thoroughly before production
2. Use UTM Parameters - Track attribution from day one
3. Monitor Acceptance Rates - Low rates indicate validation issues
4. Set Up Webhooks - Get real-time notifications
5. Configure Deduplication - Avoid duplicate leads
6. Test Error Handling - Ensure your integration handles failures
7. Review Logs Regularly - Catch issues early
8. Keep API Keys Secure - Never commit to version control
9. Document Your Setup - Help future team members
10. Ask for Help - We’re here to support you!

Welcome to Ledly! We’re excited to help you manage leads more effectively.