Centermark Developer Portal

const axios = require('axios');

const username = 'your_username';
const password = 'your_password';
const fmaId = '123456';

// Create Base64 encoded credentials
const credentials = Buffer.from(`${username}:${password}`).toString('base64');
const authHeader = `Basic ${credentials}`;

const config = {
    headers: {
        'Authorization': authHeader
    }
};

axios.get(`https://api.yodle.com/api/v2/fma/${fmaId}/leads`, config)
    .then(response => console.log(response.data))
    .catch(error => console.error(error));

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;

public class LeadsApiClient
{
    private readonly HttpClient _httpClient;
    private readonly string _username = "your_username";
    private readonly string _password = "your_password";
    
    public LeadsApiClient()
    {
        _httpClient = new HttpClient();
        _httpClient.BaseAddress = new Uri("https://api.yodle.com");
        
        // Create Base64 encoded credentials
        var credentials = Convert.ToBase64String(
            Encoding.ASCII.GetBytes($"{_username}:{_password}")
        );
        
        _httpClient.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Basic", credentials);
    }
    
    public async Task GetLeads(int fmaId, DateTime startDate, DateTime endDate)
    {
        var url = $"/api/v2/fma/{fmaId}/leads?startDate={startDate:yyyy-MM-ddTHH:mm:ss}&endDate={endDate:yyyy-MM-ddTHH:mm:ss}";
        var response = await _httpClient.GetAsync(url);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

curl -X GET \
  'https://api.yodle.com/api/v2/fma/123456/leads?startDate=2024-01-01T00:00:00&endDate=2024-12-31T23:59:59' \
  -H 'Authorization: Basic eW91cl91c2VybmFtZTp5b3VyX3Bhc3N3b3Jk'

import requests
import base64

username = 'your_username'
password = 'your_password'
fma_id = '123456'

# Create Base64 encoded credentials
credentials = base64.b64encode(f'{username}:{password}'.encode()).decode()
headers = {
    'Authorization': f'Basic {credentials}'
}

url = f'https://api.yodle.com/api/v2/fma/{fma_id}/leads'
params = {
    'startDate': '2024-01-01T00:00:00',
    'endDate': '2024-12-31T23:59:59'
}

response = requests.get(url, headers=headers, params=params)
print(response.json())

const axios = require('axios');

// Load credentials from environment variables (never hardcode)
const API_USERNAME = process.env.ENSPIRE_API_USERNAME;
const API_PASSWORD = process.env.ENSPIRE_API_PASSWORD;
const FMA_ID = process.env.FMA_ID;

class LeadsApiClient {
    constructor(username, password, fmaId) {
        this.baseUrl = 'https://api.yodle.com';
        this.fmaId = fmaId;
        this.authHeader = 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64');
    }

    async getLeads(startDate, endDate, filtered = true) {
        const allLeads = [];
        let page = 0;
        let lastPage = false;

        while (!lastPage) {
            try {
                const response = await axios.get(
                    `${this.baseUrl}/api/v2/fma/${this.fmaId}/leads`,
                    {
                        headers: { 'Authorization': this.authHeader },
                        params: { startDate, endDate, page, filtered }
                    }
                );

                const { fmaLeadResources, lastPage: isLastPage } = response.data;
                allLeads.push(...fmaLeadResources);
                lastPage = isLastPage;
                page++;

                console.log(`Retrieved page ${page}, leads count: ${fmaLeadResources.length}`);

            } catch (error) {
                if (error.response?.status === 401) {
                    throw new Error('Authentication failed. Check credentials.');
                }
                throw error;
            }
        }

        return allLeads;
    }
}

// Usage
(async () => {
    const client = new LeadsApiClient(API_USERNAME, API_PASSWORD, FMA_ID);
    
    const startDate = '2024-01-01T00:00:00';
    const endDate = '2024-01-31T23:59:59';
    
    try {
        const leads = await client.getLeads(startDate, endDate);
        console.log(`Total leads retrieved: ${leads.length}`);
        
        // Process leads by type
        leads.forEach(lead => {
            switch(lead.leadType) {
                case 'CALL':
                    console.log(`Call from ${lead.callLeadData.sourceNumber}`);
                    break;
                case 'WEB':
                    console.log(`Web lead: ${lead.webLeadData.emailAddress}`);
                    break;
                case 'OFFER':
                    console.log(`Offer lead: ${lead.offerLeadData.offerId}`);
                    break;
            }
        });
    } catch (error) {
        console.error('Failed to retrieve leads:', error.message);
        process.exit(1);
    }
})();

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class LeadsApiClient : IDisposable
{
    private readonly HttpClient _httpClient;
    private readonly string _fmaId;

    public LeadsApiClient(string username, string password, string fmaId)
    {
        _httpClient = new HttpClient
        {
            BaseAddress = new Uri("https://api.yodle.com")
        };

        var credentials = Convert.ToBase64String(
            Encoding.ASCII.GetBytes($"{username}:{password}")
        );
        _httpClient.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Basic", credentials);
        
        _fmaId = fmaId;
    }

    public async Task> GetAllLeadsAsync(
        DateTime startDate, 
        DateTime endDate, 
        bool filtered = true)
    {
        var allLeads = new List();
        int page = 0;
        bool lastPage = false;

        while (!lastPage)
        {
            var startDateStr = startDate.ToString("yyyy-MM-ddTHH:mm:ss");
            var endDateStr = endDate.ToString("yyyy-MM-ddTHH:mm:ss");
            var url = $"/api/v2/fma/{_fmaId}/leads?" +
                      $"startDate={startDateStr}&" +
                      $"endDate={endDateStr}&" +
                      $"page={page}&" +
                      $"filtered={filtered.ToString().ToLower()}";

            var response = await _httpClient.GetAsync(url);
            
            if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
            {
                throw new UnauthorizedAccessException("Authentication failed.");
            }
            
            response.EnsureSuccessStatusCode();

            var json = await response.Content.ReadAsStringAsync();
            var result = JsonSerializer.Deserialize(json);

            allLeads.AddRange(result.FmaLeadResources);
            lastPage = result.LastPage;
            page++;

            Console.WriteLine($"Retrieved page {page}, leads: {result.FmaLeadResources.Count}");
        }

        return allLeads;
    }

    public void Dispose() => _httpClient?.Dispose();
}

public class LeadsResponse
{
    public List FmaLeadResources { get; set; }
    public bool LastPage { get; set; }
}

public class Lead
{
    public long Id { get; set; }
    public int ClientId { get; set; }
    public string LeadType { get; set; }
    public string Referral { get; set; }
    public string SubReferral { get; set; }
    public string FranchiseNumber { get; set; }
    public DateTime CreatedDate { get; set; }
    public Attribution Attribution { get; set; }
    public CallLeadData CallLeadData { get; set; }
    public WebLeadData WebLeadData { get; set; }
    public OfferLeadData OfferLeadData { get; set; }
}

// Usage
class Program
{
    static async Task Main(string[] args)
    {
        // Load from configuration (appsettings.json, environment variables, etc.)
        var username = Environment.GetEnvironmentVariable("ENSPIRE_API_USERNAME");
        var password = Environment.GetEnvironmentVariable("ENSPIRE_API_PASSWORD");
        var fmaId = Environment.GetEnvironmentVariable("FMA_ID");

        using var client = new LeadsApiClient(username, password, fmaId);
        
        try
        {
            var leads = await client.GetAllLeadsAsync(
                new DateTime(2024, 1, 1),
                new DateTime(2024, 1, 31, 23, 59, 59)
            );

            Console.WriteLine($"Total leads retrieved: {leads.Count}");
            
            // Process by type
            var callLeads = leads.Where(l => l.LeadType == "CALL").ToList();
            var webLeads = leads.Where(l => l.LeadType == "WEB").ToList();
            var offerLeads = leads.Where(l => l.LeadType == "OFFER").ToList();
            
            Console.WriteLine($"Calls: {callLeads.Count}, Web: {webLeads.Count}, Offers: {offerLeads.Count}");
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Error: {ex.Message}");
            Environment.Exit(1);
        }
    }
}

<?php

class LeadsApiClient {
    private $baseUrl = 'https://api.yodle.com';
    private $fmaId;
    private $authHeader;
    
    public function __construct($username, $password, $fmaId) {
        $this->fmaId = $fmaId;
        // Create Base64 encoded credentials
        $credentials = base64_encode("$username:$password");
        $this->authHeader = "Authorization: Basic $credentials";
    }
    
    public function getAllLeads($startDate, $endDate, $filtered = true) {
        $allLeads = [];
        $page = 0;
        $lastPage = false;
        
        while (!$lastPage) {
            $url = sprintf(
                '%s/api/v2/fma/%s/leads?startDate=%s&endDate=%s&page=%d&filtered=%s',
                $this->baseUrl,
                $this->fmaId,
                urlencode($startDate),
                urlencode($endDate),
                $page,
                $filtered ? 'true' : 'false'
            );
            
            $ch = curl_init($url);
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($ch, CURLOPT_HTTPHEADER, [$this->authHeader]);
            curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
            
            $response = curl_exec($ch);
            $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
            
            if (curl_errno($ch)) {
                $error = curl_error($ch);
                curl_close($ch);
                throw new Exception("cURL error: $error");
            }
            
            curl_close($ch);
            
            if ($httpCode === 401) {
                throw new Exception('Authentication failed. Check credentials.');
            }
            
            if ($httpCode !== 200) {
                throw new Exception("HTTP error $httpCode: $response");
            }
            
            $data = json_decode($response, true);
            
            if (json_last_error() !== JSON_ERROR_NONE) {
                throw new Exception('Failed to parse JSON response');
            }
            
            $allLeads = array_merge($allLeads, $data['fmaLeadResources']);
            $lastPage = $data['lastPage'];
            $page++;
            
            echo "Retrieved page $page, leads count: " . count($data['fmaLeadResources']) . "\n";
        }
        
        return $allLeads;
    }
    
    public function processLeads($leads) {
        $stats = [
            'CALL' => 0,
            'WEB' => 0,
            'OFFER' => 0
        ];
        
        foreach ($leads as $lead) {
            $stats[$lead['leadType']]++;
            
            switch ($lead['leadType']) {
                case 'CALL':
                    if (isset($lead['callLeadData'])) {
                        echo "Call from {$lead['callLeadData']['sourceNumber']}\n";
                    }
                    break;
                case 'WEB':
                    if (isset($lead['webLeadData'])) {
                        echo "Web lead: {$lead['webLeadData']['emailAddress']}\n";
                    }
                    break;
                case 'OFFER':
                    if (isset($lead['offerLeadData'])) {
                        echo "Offer lead: {$lead['offerLeadData']['offerId']}\n";
                    }
                    break;
            }
        }
        
        return $stats;
    }
}

// Usage
try {
    // Load credentials from environment variables (never hardcode)
    $username = getenv('ENSPIRE_API_USERNAME');
    $password = getenv('ENSPIRE_API_PASSWORD');
    $fmaId = getenv('FMA_ID');
    
    if (!$username || !$password || !$fmaId) {
        throw new Exception('Required environment variables not set');
    }
    
    $client = new LeadsApiClient($username, $password, $fmaId);
    
    $startDate = '2024-01-01T00:00:00';
    $endDate = '2024-01-31T23:59:59';
    
    echo "Retrieving leads...\n";
    $leads = $client->getAllLeads($startDate, $endDate);
    
    echo "Total leads retrieved: " . count($leads) . "\n";
    
    $stats = $client->processLeads($leads);
    echo "\nBreakdown:\n";
    echo "Calls: {$stats['CALL']}\n";
    echo "Web: {$stats['WEB']}\n";
    echo "Offers: {$stats['OFFER']}\n";
    
} catch (Exception $e) {
    error_log("Failed to retrieve leads: " . $e->getMessage());
    exit(1);
}

?>

HTTP Status: 401 Unauthorized
Cause: The provided username/password credentials are incorrect or invalid.
Example Response:

{
    "timestamp": 1777652067436,
    "status": 401,
    "error": "Unauthorized",
    "message": "Bad Credentials",
    "path": "/api/v2/fma/123456/leads"
}

Resolution:

• Verify your username and password are correct
• Ensure the Base64 encoding of username:password is accurate
• Check that the Authorization header format is Basic <base64_credentials> with a space after “Basic”
• Confirm your credentials haven’t expired or been revoked
• Contact Centermark support if credentials need to be reset

HTTP Status: 400 Bad Request
Cause: The FMA ID in the URL path contains non-numeric characters or is malformed.
Example Request: GET /api/v2/fma/1234S6/leads
Example Response:

{
    "exception": "org.springframework.beans.TypeMismatchException",
    "path": "/api/v2/fma/1234S6/leads",
    "error": "Bad Request",
    "message": "Failed to convert value of type 'java.lang.String' to required type 'long'; nested exception is java.lang.NumberFormatException: For input string: \"1234S6\"",
    "timestamp": "2026-05-01T12:15:41.774-04:00",
    "status": 400
}

Resolution:

• Ensure the FMA ID contains only numeric digits
• Verify you’re using the correct FMA ID provided by Centermark
• Check for typos or extra characters in the URL path
• FMA ID should be an integer (e.g., 123456, not 1234S6)

HTTP Status: 403 Forbidden
Cause: Your credentials are valid, but you don’t have permission to access the specified FMA ID.
Example Response:

{
    "exception": "org.springframework.security.access.AccessDeniedException",
    "path": "/api/v2/fma/123456/leads",
    "error": "Forbidden",
    "message": "Not authorized",
    "timestamp": "2026-05-01T12:16:13.402-04:00",
    "status": 403
}

Resolution:

• Verify the FMA ID belongs to your organization
• Confirm your credentials have been granted access to this specific FMA
• Contact Centermark support to request access to additional FMA IDs
• Double-check you’re not using a test or staging FMA ID in production (or vice versa)

HTTP Status: 400 Bad Request
Cause: The request URL contains syntax errors, such as multiple query string delimiters.
Example Request: GET /api/v2/fma/123456/leads?startDate=2026-10-13T00:00:00&endDate=2026-01-14T23:00:00?test
Response: 400 Bad Request with no response body
Resolution:

• Check for duplicate ? characters in the URL (only one ? should appear before the first parameter)
• Use & to separate query parameters, not ?
• Ensure parameter names and values are properly URL-encoded
• Validate date formats are ISO 8601: YYYY-MM-DDTHH:mm:ss
• Example correct URL: /api/v2/fma/123456/leads?startDate=2026-01-13T00:00:00&endDate=2026-01-14T23:00:00