Company Name to Domain API in PHP: cURL + Guzzle Tutorial

Q: Does this work with older PHP versions?

PHP 7.4+ is required. The code uses null coalescing (??) and modern array syntax.

Table of Contents

The first time I had to match company names to their websites, I was staring at a CRM export with 1,500 rows and a website column that was almost entirely blank.

I was running outbound for a small B2B team back in Hamburg. Sales couldn’t reach anyone. No domain, no email pattern, no research.

So I built the fix in PHP. Why PHP? Because our whole stack ran on it. WordPress, a Laravel API, a MySQL box on shared hosting. No new language to learn, no new server to spin up.

And it worked. The pattern is simple: company name → API call → verified domain.

This is the exact walkthrough I wish someone had handed me that week. Let me show you how I built it.

📌 TL;DR: POST a company name to api.companyurlfinder.com/v1/services/name_to_domain with your x-api-key header. Get back a verified domain. Use native cURL on any shared host, or Guzzle for cleaner code. Handle all six status codes, cache results, and process CSVs in batches. Full working code below.

What you’ll build on this page

Here’s everything we’re covering, start to finish:

Setting up the Company URL Finder API with modern PHP (7.4+)
Making requests with native cURL and with the Guzzle HTTP client
Handling all six status codes without your script crashing
Bulk CSV processing that survives a mid-run crash
Real Laravel, WordPress, and CRM examples from my own testing

I ran this against 300+ company names across plain PHP, Laravel, and WordPress. Same results everywhere. That consistency is the whole point of doing this in PHP.

Let’s go 👇

Why use PHP for company name to domain conversion?

Because PHP is probably already where your data lives. If you run WordPress, Laravel, Symfony, or WooCommerce, you get native integration with no language bridge and no extra service to babysit.

I’ve built the same lookup in Python and Node too. All three work. But for data enrichment work that sits next to a CMS or a CRM, PHP wins on two boring, unglamorous things: hosting support and deployment simplicity.

Here’s why it holds up:

Universal hosting. Every shared host runs PHP. Deploy anywhere, no special config.
Built-in HTTP. cURL ships with PHP. No dependency needed for a basic call.
Native JSON. json_decode() and json_encode() handle responses with zero extra libraries.
Framework support. Laravel, Symfony, and CodeIgniter give you HTTP clients and queues out of the box.

I’ve deployed these scripts on shared hosting, a VPS, and a serverless runner. Zero code changes between them. That’s rare, and it’s the reason I keep reaching for PHP on enrichment jobs.

What you need before starting

Let’s make sure you’ve got the basics ready.

Required:

PHP 7.4 or higher (check with php --version)
The cURL extension enabled (it almost always is)
A Company URL Finder API key (grab a free one at companyurlfinder.com/signup)
Composer, if you want dependency management (optional)
A code editor (VS Code, PHPStorm, Sublime, whatever you like)

Nice to have:

Guzzle HTTP client (composer require guzzlehttp/guzzle)
vlucas/phpdotenv for environment variables (composer require vlucas/phpdotenv)
league/csv for bulk processing (composer require league/csv)

I’m on PHP 8.2 and Ubuntu here, but this runs the same on PHP 7.4+ across any OS.

One rule I’ll repeat until you’re sick of it: keep your API key in an environment variable or a config file outside your web root. Never hardcode it. I’ll show you the safe pattern in a minute.

Step 1: Install the dependencies (optional)

Using Composer? Make a directory and initialize it:

mkdir company-domain-finder
cd company-domain-finder
composer init

Then pull in Guzzle for cleaner requests:

composer require guzzlehttp/guzzle
composer require vlucas/phpdotenv

That’s it. Two packages, about 15 seconds.

Why bother with Guzzle over cURL? Cleaner syntax, better error handling, and easy retry logic. Plain cURL is totally fine for simple jobs. Guzzle just saves you headaches once things go to production. The full Guzzle docs are worth a bookmark.

No dependencies? Native PHP works fine

Don’t want to touch Composer? PHP’s built-in cURL does the job. Check it’s available first:

<?php
// Check if cURL is enabled
if (!function_exists('curl_init')) {
    die('cURL extension is not enabled');
}

echo "✅ cURL is available\n";

I’ll show both paths. Guzzle for modern projects, cURL for maximum compatibility. If you ever want to dig into the raw functions, the PHP cURL manual covers every option.

Step 2: Set up API authentication

Create a .env file in your project root:

COMPANY_URL_FINDER_API_KEY=your_api_key_here

Add it to .gitignore right away:

.env
vendor/

Now build your main file (index.php) with a secure environment load:

<?php
require_once __DIR__ . '/vendor/autoload.php';

use Dotenv\Dotenv;

// Load environment variables
$dotenv = Dotenv::createImmutable(__DIR__);
$dotenv->load();

$apiKey = $_ENV['COMPANY_URL_FINDER_API_KEY'] ?? null;

if (!$apiKey) {
    throw new Exception('API key not found. Check your .env file.');
}

echo "✅ API key loaded successfully\n";

This keeps your key out of your code but still easy to reach.

No Composer? Use a config file

If you’re skipping Composer, drop a config file outside your web root:

<?php
// config.php (stored outside public_html)
return [
    'api_key' => 'your_api_key_here',
    'api_url' => 'https://api.companyurlfinder.com/v1/services/name_to_domain'
];

Then load it:

<?php
$config = require __DIR__ . '/../config.php';
$apiKey = $config['api_key'];

Why this matters

Because a leaked key is a fast, expensive mistake. Three quick reasons to do it right:

Security. Hardcoded keys in public repos get scraped by bots within hours. GitHub’s own scanner catches them almost instantly.
Team work. Each developer uses their own key. Share the template, not the secret.
Environments. Different keys for dev, staging, and production. Change one file, not a hundred code spots.

I once committed a key to a public repo. It was compromised in 31 minutes. Learn from my dumb, expensive lesson.

Step 3: Make your first request with cURL

Here’s the full code to convert a company name to a domain with native cURL:

<?php
function findCompanyDomain($companyName, $countryCode = 'US') {
    $apiKey = $_ENV['COMPANY_URL_FINDER_API_KEY'];
    $apiUrl = 'https://api.companyurlfinder.com/v1/services/name_to_domain';

    // Prepare POST data
    $postData = http_build_query([
        'company_name' => $companyName,
        'country_code' => $countryCode
    ]);

    // Initialize cURL
    $ch = curl_init($apiUrl);

    // Set cURL options
    curl_setopt_array($ch, [
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => $postData,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => [
            'x-api-key: ' . $apiKey,
            'Content-Type: application/x-www-form-urlencoded'
        ],
        CURLOPT_TIMEOUT => 10,
        CURLOPT_FOLLOWLOCATION => true
    ]);

    // Execute request
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    $error = curl_error($ch);

    curl_close($ch);

    // Handle errors
    if ($error) {
        return [
            'success' => false,
            'error' => $error,
            'http_code' => null
        ];
    }

    // Parse JSON response
    $data = json_decode($response, true);

    return [
        'success' => true,
        'http_code' => $httpCode,
        'data' => $data
    ];
}

// Test it
$result = findCompanyDomain('Microsoft', 'US');
print_r($result);

Run it with php index.php.

You’ll get back something like this:

Array
(
    [success] => 1
    [http_code] => 200
    [data] => Array
        (
            [status] => 1
            [code] => 1000
            [errors] => Array()
            [data] => Array
                (
                    [exists] => 1
                    [domain] => https://microsoft.com/
                )
        )
)

That’s it. Microsoft’s domain, back in about 185ms in my testing.

What’s in the response?

Five fields matter. Read them in this order and your code stays clean:

status: 1 means success, 0 means error. Check this before anything else.
code: internal status code. 1000 = success. Other codes flag specific errors.
exists: 1 or true when a domain was found. This is your filter for good matches.
domain: the verified URL, protocol included (https://).
errors: an array of details when status is 0. Empty on success.

The exists field is what protects your data quality. A 200 response doesn’t always mean a match was found, so gate every write on exists being true before you save a domain.

Step 4: Using the Guzzle HTTP client

For modern projects, Guzzle gives you cleaner syntax and friendlier error handling:

<?php
require_once __DIR__ . '/vendor/autoload.php';

use GuzzleHttp\Client;
use GuzzleHttp\Exception\GuzzleException;

function findCompanyDomain($companyName, $countryCode = 'US') {
    $apiKey = $_ENV['COMPANY_URL_FINDER_API_KEY'];
    $apiUrl = 'https://api.companyurlfinder.com/v1/services/name_to_domain';

    $client = new Client([
        'timeout' => 10.0,
        'headers' => [
            'x-api-key' => $apiKey,
            'Content-Type' => 'application/x-www-form-urlencoded'
        ]
    ]);

    try {
        $response = $client->post($apiUrl, [
            'form_params' => [
                'company_name' => $companyName,
                'country_code' => $countryCode
            ]
        ]);

        $statusCode = $response->getStatusCode();
        $body = json_decode($response->getBody(), true);

        return [
            'success' => true,
            'http_code' => $statusCode,
            'data' => $body
        ];

    } catch (GuzzleException $e) {
        return [
            'success' => false,
            'error' => $e->getMessage(),
            'http_code' => $e->getCode()
        ];
    }
}

// Test it
$result = findCompanyDomain('Google', 'US');
print_r($result);

Guzzle handles a few things for you automatically:

Exceptions on errors. A failed request throws, so your catch block owns the recovery.
Connection pooling. Reuses connections across multiple requests.
Retry middleware. Add retry logic for temporary failures with a few lines.
PSR-7 messages. Standard HTTP interfaces that play nice with other libraries.

I lean on Guzzle for production apps. The cleaner code means fewer bugs at 2am.

cURL or Guzzle? Here’s how to pick

Short answer: use native cURL when you can’t run Composer, and Guzzle when you can. Both hit the same endpoint and get the same result. The difference is how much they do for you.

What you care about	Native cURL	Guzzle
Install step	None, built into PHP	Composer required
Shared hosting	Works everywhere	Needs Composer access
Syntax	Verbose, manual options	Clean, object-based
Error handling	Check return values yourself	Throws exceptions
Retries	Write your own loop	Middleware, a few lines
Best for	Quick scripts, legacy hosts	Production apps, frameworks

My rule of thumb: prototyping or dropping a file on cheap hosting → cURL. A real app that other people will maintain → Guzzle. If you’re already inside Laravel, skip both and use the framework client (Step 7).

Step 5: Handle all six status codes

The API returns six HTTP status codes. Handle every one and your bulk jobs stop dying on row 200.

<?php
function findCompanyDomain($companyName, $countryCode = 'US', $maxRetries = 3) {
    $apiKey = $_ENV['COMPANY_URL_FINDER_API_KEY'];
    $apiUrl = 'https://api.companyurlfinder.com/v1/services/name_to_domain';

    for ($attempt = 0; $attempt < $maxRetries; $attempt++) {
        // Initialize cURL
        $ch = curl_init($apiUrl);

        $postData = http_build_query([
            'company_name' => $companyName,
            'country_code' => $countryCode
        ]);

        curl_setopt_array($ch, [
            CURLOPT_POST => true,
            CURLOPT_POSTFIELDS => $postData,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'x-api-key: ' . $apiKey,
                'Content-Type: application/x-www-form-urlencoded'
            ],
            CURLOPT_TIMEOUT => 10
        ]);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $curlError = curl_error($ch);

        curl_close($ch);

        // Handle cURL errors
        if ($curlError) {
            if ($attempt < $maxRetries - 1) {
                sleep(pow(2, $attempt)); // Exponential backoff: 1s, 2s, 4s
                continue;
            }
            return [
                'success' => false,
                'company' => $companyName,
                'error' => 'Network error: ' . $curlError,
                'status_code' => null
            ];
        }

        $data = json_decode($response, true);

        // Status 200: Success
        if ($httpCode === 200) {
            return [
                'success' => true,
                'company' => $companyName,
                'domain' => $data['data']['domain'] ?? null,
                'exists' => $data['data']['exists'] ?? false,
                'status_code' => 200
            ];
        }

        // Status 400: Not enough credits
        if ($httpCode === 400) {
            return [
                'success' => false,
                'company' => $companyName,
                'error' => 'Not enough credits',
                'status_code' => 400
            ];
        }

        // Status 401: Invalid API key
        if ($httpCode === 401) {
            return [
                'success' => false,
                'company' => $companyName,
                'error' => 'Invalid API key',
                'status_code' => 401
            ];
        }

        // Status 404: No data found
        if ($httpCode === 404) {
            return [
                'success' => false,
                'company' => $companyName,
                'error' => 'No data found',
                'status_code' => 404
            ];
        }

        // Status 422: Invalid data format
        if ($httpCode === 422) {
            return [
                'success' => false,
                'company' => $companyName,
                'error' => 'Invalid data format',
                'status_code' => 422
            ];
        }

        // Status 500: Server error - retry
        if ($httpCode === 500) {
            if ($attempt < $maxRetries - 1) {
                sleep(pow(2, $attempt)); // Exponential backoff
                continue;
            }
            return [
                'success' => false,
                'company' => $companyName,
                'error' => 'Server error after retries',
                'status_code' => 500
            ];
        }

        // Unexpected status code
        return [
            'success' => false,
            'company' => $companyName,
            'error' => 'Unexpected status code: ' . $httpCode,
            'status_code' => $httpCode
        ];
    }

    return [
        'success' => false,
        'company' => $companyName,
        'error' => 'Max retries exceeded',
        'status_code' => null
    ];
}

// Test with different scenarios
$result1 = findCompanyDomain('Apple', 'US');
echo "Test 1: "; print_r($result1); echo "\n";

$result2 = findCompanyDomain('NonexistentCompany12345', 'US');
echo "Test 2: "; print_r($result2); echo "\n";

Here’s what each code means and what to actually do about it:

Code	Meaning	What to do
200	Success	Check the `exists` field, then save the domain
400	Not enough credits	Stop the batch, top up, resume
401	Invalid API key	Fix your .env or config, don’t retry
404	No data found	Log it, move on. Often a typo or a brand-new company
422	Invalid data format	Check your fields and country code, don’t retry
500	Server error	Retry with backoff (1s, 2s, 4s)

I tested this with deliberately broken inputs. It handles every edge case without crashing.

Error handling that saved me hours

A few habits worth stealing:

Log your status codes. Seeing a pile of 404s? Your input data needs cleaning, not your code.
Retry only 500s and timeouts. A 400, 401, 404, or 422 won’t fix itself with retries. You’ll just burn time.
Set a sane timeout. 10 seconds is generous. Drop to 5 for latency-sensitive apps.
Use error_log(). Track failures in production. This is your black box when something breaks.

These patterns saved me real debugging hours when I was building production enrichment scripts. Boring, but they hold up.

Step 6: Process companies in bulk from a CSV

Single lookups are great for testing. Real work needs bulk.

Here’s how I process a CSV with hundreds of company names:

<?php
function processBulkCompanies($inputFile, $outputFile) {
    // Check if input file exists
    if (!file_exists($inputFile)) {
        throw new Exception("Input file not found: $inputFile");
    }

    // Open input CSV
    $inputHandle = fopen($inputFile, 'r');
    if (!$inputHandle) {
        throw new Exception("Cannot open input file");
    }

    // Read header row
    $headers = fgetcsv($inputHandle);
    $companyNameIndex = array_search('company_name', $headers);
    $countryCodeIndex = array_search('country_code', $headers);

    if ($companyNameIndex === false) {
        throw new Exception("CSV must contain 'company_name' column");
    }

    // Prepare output CSV
    $outputHandle = fopen($outputFile, 'w');
    $outputHeaders = array_merge($headers, ['domain', 'lookup_status', 'status_code']);
    fputcsv($outputHandle, $outputHeaders);

    // Process each company
    $processed = 0;
    $successful = 0;
    $startTime = time();

    echo "📋 Starting bulk processing...\n";

    while (($row = fgetcsv($inputHandle)) !== false) {
        $companyName = $row[$companyNameIndex] ?? '';
        $countryCode = $countryCodeIndex !== false ? ($row[$countryCodeIndex] ?? 'US') : 'US';

        // Skip empty names
        if (empty(trim($companyName))) {
            $row[] = null;
            $row[] = 'empty_name';
            $row[] = null;
            fputcsv($outputHandle, $row);
            continue;
        }

        // Find domain
        $result = findCompanyDomain($companyName, $countryCode);

        if ($result['success'] && $result['exists']) {
            $row[] = $result['domain'];
            $row[] = 'found';
            $row[] = $result['status_code'];
            $successful++;
        } else {
            $row[] = null;
            $row[] = $result['error'] ?? 'not_found';
            $row[] = $result['status_code'] ?? null;
        }

        fputcsv($outputHandle, $row);

        $processed++;

        // Progress update every 50 companies
        if ($processed % 50 === 0) {
            $elapsed = time() - $startTime;
            $rate = $processed / max($elapsed, 1);
            echo "✅ Processed $processed companies ($successful found) - Rate: " .
                 number_format($rate, 1) . " companies/sec\n";
        }

        // Rate limiting: small delay between requests
        usleep(100000); // 0.1 second delay
    }

    fclose($inputHandle);
    fclose($outputHandle);

    // Final summary
    $totalTime = time() - $startTime;
    $successRate = $processed > 0 ? ($successful / $processed * 100) : 0;

    echo "\n✅ Processing complete!\n";
    echo "✅ Total companies: $processed\n";
    echo "✅ Domains found: $successful (" . number_format($successRate, 1) . "%)\n";
    echo "✅ Time elapsed: $totalTime seconds\n";
    echo "💾 Results saved to: $outputFile\n";
}

// Run bulk processing
processBulkCompanies('companies.csv', 'companies_enriched.csv');

I ran this on a 500-row CSV. Here’s what I saw:

Time: about 55 seconds with a 0.1s delay between requests.
Match rate: 94.3% of names resolved to a domain.
Memory: 8MB peak. PHP streams CSV rows efficiently.

Those progress updates matter more than they look. On a big batch, you want to know exactly where you are.

Bulk processing habits worth keeping

Stream, don’t load. fgetcsv() reads row by row, so 100,000-row files won’t blow up your memory.
Save incrementally. Write each result immediately. Crash at row 457? You keep 456.
Isolate errors. One bad row doesn’t kill the batch. Each company stands alone.
Track progress. Updates every 50 rows let you estimate the finish.

I once processed 8,000 companies and the server died at row 7,234. Incremental saving meant I lost 34 rows, not 7,234. Always write as you go.

One more thing that lifts your match rate for free: your inputs. “Acme GmbH”, “ACME” and “Acme Gmbh.” are the same company to you, but not always to a matcher. Normalizing names before you send them is basic data matching hygiene, and it pushes your results up a few points.

💡 Tip: Feeding a big list? Clean it first. A quick pass to trim whitespace, drop duplicates, and fix obvious typos before you call the API is the cheapest match-rate boost you'll ever get.

Step 7: Laravel integration

Laravel folks can use the framework’s HTTP client and skip Guzzle entirely. Wrap it in a service class:

<?php
namespace App\Services;

use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;

class CompanyDomainFinder
{
    protected $apiKey;
    protected $apiUrl;

    public function __construct()
    {
        $this->apiKey = config('services.company_url_finder.api_key');
        $this->apiUrl = 'https://api.companyurlfinder.com/v1/services/name_to_domain';
    }

    public function findDomain(string $companyName, string $countryCode = 'US'): array
    {
        try {
            $response = Http::timeout(10)
                ->withHeaders([
                    'x-api-key' => $this->apiKey,
                    'Content-Type' => 'application/x-www-form-urlencoded'
                ])
                ->asForm()
                ->post($this->apiUrl, [
                    'company_name' => $companyName,
                    'country_code' => $countryCode
                ]);

            if ($response->successful()) {
                $data = $response->json();

                return [
                    'success' => true,
                    'company' => $companyName,
                    'domain' => $data['data']['domain'] ?? null,
                    'exists' => $data['data']['exists'] ?? false,
                    'status_code' => 200
                ];
            }

            return $this->handleErrorResponse($response, $companyName);

        } catch (\Exception $e) {
            Log::error('Company domain lookup failed', [
                'company' => $companyName,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'company' => $companyName,
                'error' => $e->getMessage(),
                'status_code' => null
            ];
        }
    }

    protected function handleErrorResponse($response, string $companyName): array
    {
        $statusCode = $response->status();

        $errorMessages = [
            400 => 'Not enough credits',
            401 => 'Invalid API key',
            404 => 'No data found',
            422 => 'Invalid data format',
            500 => 'Server error'
        ];

        return [
            'success' => false,
            'company' => $companyName,
            'error' => $errorMessages[$statusCode] ?? 'Unknown error',
            'status_code' => $statusCode
        ];
    }
}

Wrapping the lookup in a class like this is standard object-oriented PHP, and it keeps your controllers thin. Add the config to config/services.php:

<?php
return [
    // ... other services

    'company_url_finder' => [
        'api_key' => env('COMPANY_URL_FINDER_API_KEY'),
    ],
];

Then use it in a controller:

<?php
namespace App\Http\Controllers;

use App\Services\CompanyDomainFinder;
use Illuminate\Http\Request;

class CompanyController extends Controller
{
    protected $domainFinder;

    public function __construct(CompanyDomainFinder $domainFinder)
    {
        $this->domainFinder = $domainFinder;
    }

    public function findDomain(Request $request)
    {
        $request->validate([
            'company_name' => 'required|string|max:255',
            'country_code' => 'nullable|string|size:2'
        ]);

        $result = $this->domainFinder->findDomain(
            $request->company_name,
            $request->country_code ?? 'US'
        );

        return response()->json($result);
    }
}

Laravel’s HTTP client gives you retries, middleware, and tidy error handling for free. The Laravel docs cover the client in detail if you want to add retry or pooling. This is my go-to for CRM enrichment inside a real app.

Step 8: WordPress plugin integration

WordPress developers can drop this straight into a plugin or theme using wp_remote_post():

<?php
/**
 * Plugin Name: Company Domain Finder
 * Description: Find company domains using Company URL Finder API
 * Version: 1.0.0
 */

class Company_Domain_Finder_Plugin {

    private $api_key;

    public function __construct() {
        // Get API key from WordPress options
        $this->api_key = get_option('company_url_finder_api_key');

        // Add admin menu
        add_action('admin_menu', [$this, 'add_admin_menu']);

        // Register AJAX handlers
        add_action('wp_ajax_find_company_domain', [$this, 'ajax_find_domain']);
    }

    public function add_admin_menu() {
        add_menu_page(
            'Company Domain Finder',
            'Domain Finder',
            'manage_options',
            'company-domain-finder',
            [$this, 'admin_page'],
            'dashicons-search'
        );
    }

    public function admin_page() {
        ?>
        <div class="wrap">
            <h1>Company Domain Finder</h1>
            <form method="post">
                <table class="form-table">
                    <tr>
                        <th>API Key</th>
                        <td>
                            <input type="text" name="api_key"
                                   value="<?php echo esc_attr($this->api_key); ?>"
                                   class="regular-text" />
                        </td>
                    </tr>
                </table>
                <?php submit_button('Save Settings'); ?>
            </form>

            <hr>

            <h2>Find Company Domain</h2>
            <input type="text" id="company-name" placeholder="Enter company name..."
                   class="regular-text" />
            <button type="button" id="find-domain-btn" class="button button-primary">
                Find Domain
            </button>
            <div id="result" style="margin-top: 20px;"></div>
        </div>

        <script>
        jQuery(document).ready(function($) {
            $('#find-domain-btn').on('click', function() {
                var companyName = $('#company-name').val();

                $.post(ajaxurl, {
                    action: 'find_company_domain',
                    company_name: companyName
                }, function(response) {
                    if (response.success) {
                        $('#result').html('<strong>Domain:</strong> ' +
                                        '<a href="' + response.data.domain + '" target="_blank">' +
                                        response.data.domain + '</a>');
                    } else {
                        $('#result').html('<span style="color: red;">Error: ' +
                                        response.data.error + '</span>');
                    }
                });
            });
        });
        </script>
        <?php

        // Handle form submission
        if (isset($_POST['api_key'])) {
            update_option('company_url_finder_api_key', sanitize_text_field($_POST['api_key']));
            echo '<div class="notice notice-success"><p>Settings saved!</p></div>';
        }
    }

    public function ajax_find_domain() {
        $company_name = sanitize_text_field($_POST['company_name']);

        $result = $this->find_company_domain($company_name);

        if ($result['success']) {
            wp_send_json_success([
                'domain' => $result['domain']
            ]);
        } else {
            wp_send_json_error([
                'error' => $result['error']
            ]);
        }
    }

    private function find_company_domain($company_name, $country_code = 'US') {
        $api_url = 'https://api.companyurlfinder.com/v1/services/name_to_domain';

        $response = wp_remote_post($api_url, [
            'timeout' => 10,
            'headers' => [
                'x-api-key' => $this->api_key,
                'Content-Type' => 'application/x-www-form-urlencoded'
            ],
            'body' => [
                'company_name' => $company_name,
                'country_code' => $country_code
            ]
        ]);

        if (is_wp_error($response)) {
            return [
                'success' => false,
                'error' => $response->get_error_message()
            ];
        }

        $status_code = wp_remote_retrieve_response_code($response);
        $body = json_decode(wp_remote_retrieve_body($response), true);

        if ($status_code === 200 && isset($body['data']['domain'])) {
            return [
                'success' => true,
                'domain' => $body['data']['domain']
            ];
        }

        return [
            'success' => false,
            'error' => 'Domain not found'
        ];
    }
}

// Initialize plugin
new Company_Domain_Finder_Plugin();

The wp_remote_post() helper wraps HTTP calls with WordPress security built in, so you don’t need cURL or Guzzle here. If you’re new to plugin structure, the WordPress plugin handbook is the reference to keep open. This pattern is great for extending a business directory or a membership site.

A real example: enriching a CRM

This is the script I mentioned at the top. Here’s the actual shape of it.

Problem: 1,500 companies in the CRM, no website data. Sales was stuck.
Solution: a PHP script enriching 100 companies per batch, writing straight to MySQL.
Result: 1,394 domains found (92.9%) in about 3 hours. The team closed 18 deals off the enriched list.

The code:

<?php
require_once __DIR__ . '/vendor/autoload.php';

use Dotenv\Dotenv;

// Load environment
$dotenv = Dotenv::createImmutable(__DIR__);
$dotenv->load();

// Database connection
$db = new PDO(
    'mysql:host=' . $_ENV['DB_HOST'] . ';dbname=' . $_ENV['DB_NAME'],
    $_ENV['DB_USER'],
    $_ENV['DB_PASS']
);

function enrichCRMCompanies($db, $batchSize = 100) {
    // Get companies without domains
    $stmt = $db->prepare("
        SELECT id, company_name, country_code
        FROM companies
        WHERE domain IS NULL OR domain = ''
        LIMIT :batch_size
    ");
    $stmt->bindValue(':batch_size', $batchSize, PDO::PARAM_INT);
    $stmt->execute();

    $companies = $stmt->fetchAll(PDO::FETCH_ASSOC);

    if (empty($companies)) {
        echo "✅ All companies enriched!\n";
        return;
    }

    echo "📋 Processing " . count($companies) . " companies...\n";

    $enriched = 0;

    foreach ($companies as $company) {
        $result = findCompanyDomain($company['company_name'], $company['country_code'] ?? 'US');

        if ($result['success'] && $result['exists']) {
            // Update database with found domain
            $updateStmt = $db->prepare("
                UPDATE companies
                SET domain = :domain,
                    enriched_at = NOW(),
                    enrichment_status = 'found'
                WHERE id = :id
            ");
            $updateStmt->execute([
                'domain' => $result['domain'],
                'id' => $company['id']
            ]);

            $enriched++;
            echo "✅ {$company['company_name']}: {$result['domain']}\n";
        } else {
            // Mark as not found
            $updateStmt = $db->prepare("
                UPDATE companies
                SET enrichment_status = :status,
                    enriched_at = NOW()
                WHERE id = :id
            ");
            $updateStmt->execute([
                'status' => $result['error'] ?? 'not_found',
                'id' => $company['id']
            ]);

            echo "❌ {$company['company_name']}: {$result['error']}\n";
        }

        usleep(100000); // 0.1s delay between requests
    }

    echo "\n✅ Batch complete: $enriched domains found\n";
}

// Run enrichment
enrichCRMCompanies($db, 100);

I ran this on a cron every hour until the whole table was filled. Zero manual work after setup. That’s the goal with any enrichment job. Set it, let it run, check the numbers.

Frequently asked questions

Does this work with older PHP versions?

PHP 7.4+ is required. The code uses null coalescing (??) and modern array syntax.

On PHP 5.6 to 7.3 you’d swap ?? for ternaries, drop the strict type hints, and use older array syntax. But honestly? If you’re on 5.6, upgrading is the real fix. Security patches ended back in 2019.

What’s the rate limit?

100 requests per second. That’s 6,000 companies a minute before you’d hit any throttle.

In practice you’ll almost never reach it unless you’re running many parallel workers across servers. For real-time enrichment, batch jobs, or background workers, you’ve got plenty of room. I’ve never hit the ceiling in normal use.

Can I use this on shared hosting?

Yes. As long as your host has cURL enabled (nearly all do), you’re good.

No special extensions. No command-line access needed. No Composer if you stick with native cURL. I’ve run this on Bluehost, HostGator, SiteGround, and GoDaddy with no changes. Upload the file, run it, done.

How do I handle international characters in company names?

Use UTF-8 everywhere. The API accepts UTF-8 encoded POST data, so set your encoding and go:

<?php
// Ensure UTF-8 encoding
mb_internal_encoding('UTF-8');

// Works with international characters
$result = findCompanyDomain('Société Générale', 'FR');
$result = findCompanyDomain('東京電力', 'JP');
$result = findCompanyDomain('Росте́леком', 'RU');

Just save your PHP files as UTF-8 without a BOM and set proper headers. Accented and non-Latin names resolve fine.

Can I cache results to reduce API calls?

Yes, and you should. The same company names come up over and over, so caching is basically free savings:

<?php
function findWithCache($companyName, $countryCode = 'US') {
    $cacheFile = 'cache/' . md5($companyName . $countryCode) . '.json';

    // Check cache first (valid for 30 days)
    if (file_exists($cacheFile) && time() - filemtime($cacheFile) < 30 * 24 * 3600) {
        return json_decode(file_get_contents($cacheFile), true);
    }

    // Make API call
    $result = findCompanyDomain($companyName, $countryCode);

    // Cache successful results
    if ($result['success']) {
        file_put_contents($cacheFile, json_encode($result));
    }

    return $result;
}

Caching cut my API usage by 71% in one project. Cache successful lookups for 30 days and you’ll feel it on your bill.

Can I look up who owns a domain with this API?

No, that’s a different tool for a different question. WHOIS (and its successor protocol, RDAP) tells you who registered a domain you already know. A name-to-domain API answers the opposite question: which domain belongs to this company name.

People conflate the two all the time, so here’s the split. Start with a domain and want ownership or registration details? Use a WHOIS or RDAP lookup. Start with a company name and want its website? That’s this tutorial. And if you need both, run this API first, then feed the returned domain into WHOIS.

Which PHP method should I actually use?

Match the tool to the project. Native cURL for quick scripts and locked-down shared hosting. Guzzle for standalone apps. The framework client if you’re inside Laravel or WordPress already. Same endpoint, same result, three routes there.

You’ve got everything you need

Look at what you can do now:

Load your API key securely with a .env file or a config outside the web root
Call the API with native cURL or Guzzle, whichever your host allows
Handle all six status codes with retries and backoff
Process big CSVs with streaming and incremental saves
Wire it into Laravel, WordPress, or a straight-to-MySQL CRM script

Working in another language too? I’ve written the same walkthrough for Java and JavaScript, and if you’re comparing options, here are the best company name to domain APIs and a big list of real use cases to steal ideas from.

The whole thing takes about 20 minutes to wire up the first time. After that, it just runs.

Ready to fill in those blank website columns? Grab your free API key and you’ll have your first lookup running in a couple of minutes. You got this.

🚀 Try Our Company Name to Domain Service

Discover the fastest and most accurate tool to convert company names to domains. It takes less than a minute to sign up, and you can start seeing results right away.

Start Free Trial →