# Company URL Finder API Documentation
Source: https://apidocs.companyurlfinder.com/apis

Convert company names to verified website domains through simple HTTP requests that integrate into any workflow.

Company URL Finder's RESTful API provides specialized endpoints that access our database of 85M+ verified company domains, refreshed continuously for maximum accuracy.

Whether you're building CRM automation, data enrichment pipelines, or lead generation platforms, our API delivers precise domain matching that powers your entire sales and marketing stack.

## Why Developers Choose Our API

### Simple Integration

One endpoint, two parameters, instant results. Integration takes minutes, not weeks.

### High Accuracy

Our proprietary matching algorithm delivers 95%+ accuracy across global company databases by combining name normalization, country filtering, and real-time verification.

### Structured Responses

Every API call returns clean JSON with status codes, domain URLs, and existence flags—no parsing headaches.

### Credit-Based Pricing

You only pay for successful domain matches. Failed lookups don't consume credits, making Company URL Finder the most cost-effective domain resolution solution.

### No Rate Limit Penalties

Our infrastructure handles bulk requests without throttling. Process thousands of companies without delays or 429 errors.

### Global Coverage

Match companies across 195+ countries with optional country-code filtering for improved precision in markets with name overlap.


# Authentication
Source: https://apidocs.companyurlfinder.com/apis/authentication

You'll need to authenticate your requests to access any of the endpoints in the Company URL Finder API. In this guide, we'll look at how authentication works.

## API Key authentication

To access the APIs provided by Company URL Finder, you will need to obtain an API key, which serves as the authentication mechanism for secure and authorized access to the platform's services.

This API key acts as a unique identifier that establishes the identity and permissions of your application, ensuring that only authorized users can interact with the Company URL Finder APIs. By requiring an API key for authentication, Company URL Finder maintains a secure and controlled environment, protecting the privacy and integrity of the data exchanged between your application and the platform.

## Get your API key

To obtain your API key, you must first log in to your Company URL Finder dashboard, which serves as a centralized hub for managing your account and accessing the various features and services provided by Company URL Finder. Once you have successfully logged in, navigate to the designated section or settings page within the dashboard where API key management is available

Within this section, you will find the option to generate or retrieve your unique API key. By clicking on the corresponding button or link, Company URL Finder will generate a secure and individualized API key specifically tied to your account and application.

<a href="https://companyurlfinder.com/login">
  Get your API key

  <Icon icon="arrow-right" />
</a>

## Explore APIs

This next section provides a comprehensive list of all the available APIs, along with detailed instructions on how to use them. Additionally, you will find pseudocode examples in various programming languages for your reference.


# Domain to Company Name API
Source: https://apidocs.companyurlfinder.com/apis/company-domain-to-name

Company domains fill your analytics dashboards, web logs, and inbound forms every day. Without matching those domains to verified company names, you're staring at raw URLs with zero context. That's where our Domain to Company Name API comes in. We resolves domains against our database of 285M+ verified company records—returning accurate company names in milliseconds.

This API turns anonymous website traffic and bare-URL lead lists into enriched company names your sales and marketing teams can act on immediately. It plugs into any workflow—reverse IP identification, CRM enrichment pipelines, form-fill automation, real-time visitor intelligence systems.

<div>
  <div>
    <div>
      <div>
        <Badge>post</Badge>
        <p>[https://api.companyurlfinder.com/v2/services/domain\_to\_name](https://api.companyurlfinder.com/v2/services/domain_to_name)</p>
      </div>
    </div>
  </div>

  <Badge icon="star">
    Credit usage is 1 per record found.
  </Badge>

  <div>
    <div>
      <div>
        ## Attributes

        <ParamField type="string">
          Your API key.
        </ParamField>

        <ParamField type="string">
          Company Domain
        </ParamField>
      </div>
    </div>

    <div>
      <CodeGroup>
        ```bash Request theme={null}
        curl --location 'https://api.companyurlfinder.com/v2/services/domain_to_name' \
        --header 'Content-Type: application/x-www-form-urlencoded' \
        --header 'x-api-key: your_api_key' \
        --data-urlencode 'domain=ibm.com'
        ```

        ```javascript Request theme={null}
        const myHeaders = new Headers();
        myHeaders.append("Content-Type", "application/x-www-form-urlencoded");
        myHeaders.append("x-api-key", "your_api_key");

        const urlencoded = new URLSearchParams();
        urlencoded.append("domain", "ibm.com");

        const requestOptions = {
            method: "POST",
            headers: myHeaders,
            body: urlencoded,
            redirect: "follow"
        };

        try {
            const response = await fetch("https://api.companyurlfinder.com/v2/services/domain_to_name", requestOptions);
            const result = await response.text();
            console.log(result)
        } catch (error) {
            console.error(error);
        };
        ```

        ```python Request theme={null}
        import requests

        url = "https://api.companyurlfinder.com/v2/services/domain_to_name"

        payload = 'domain=ibm.com'
        headers = {
            'Content-Type': 'application/x-www-form-urlencoded',
            'x-api-key': 'your_api_key'
        }

        response = requests.request("POST", url, headers=headers, data=payload)

        print(response.text)
        ```

        ```php Request  theme={null}
        $client = new Client();
        $headers = [
            'Content-Type' => 'application/x-www-form-urlencoded',
            'x-api-key' => 'your_api_key'
        ];
        $options = [
            'form_params' => [
            'domain' => 'ibm.com'
        ]];
        $request = new Request('POST', 'https://api.companyurlfinder.com/v2/services/domain_to_name', $headers);
        $res = $client->sendAsync($request, $options)->wait();
        echo $res->getBody();
        ```
      </CodeGroup>

      <CodeGroup>
        ```json Response theme={null}
        {
        "status": 1,
            "code": 1000,
            "errors": {},
            "data": {
                "exists": true,
                "company_name": "IBM",
                "remaining_credits": 9999
            }
        }
        ```
      </CodeGroup>
    </div>
  </div>
</div>

<StatusCodes />

<div>
  ## Company Domain to Name API in Javascript

  <CodeGroup>
    ```javascript Request theme={null}
    const myHeaders = new Headers();
    myHeaders.append("Content-Type", "application/x-www-form-urlencoded");
    myHeaders.append("x-api-key", "your_api_key");

    const urlencoded = new URLSearchParams();
    urlencoded.append("domain", "ibm.com");

    const requestOptions = {
        method: "POST",
        headers: myHeaders,
        body: urlencoded,
        redirect: "follow"
    };

    try {
        const response = await fetch("https://api.companyurlfinder.com/v2/services/domain_to_name", requestOptions);
        const result = await response.text();
        console.log(result)
    } catch (error) {
        console.error(error);
    };
    ```
  </CodeGroup>
</div>

<div>
  ## Company Domain to Name API in Python

  <CodeGroup>
    ```python Request theme={null}
    import requests

    url = "https://api.companyurlfinder.com/v2/services/domain_to_name"

    payload = 'domain=ibm.com'
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded',
        'x-api-key': 'your_api_key'
    }

    response = requests.request("POST", url, headers=headers, data=payload)

    print(response.text)
    ```
  </CodeGroup>
</div>

<div>
  ## Company Domain to Name API in PHP

  <CodeGroup>
    ```php Request theme={null}
    $client = new Client();
    $headers = [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'x-api-key' => 'your_api_key'
    ];
    $options = [
        'form_params' => [
        'domain' => 'ibm.com'
    ]];
    $request = new Request('POST', 'https://api.companyurlfinder.com/v2/services/domain_to_name', $headers);
    $res = $client->sendAsync($request, $options)->wait();
    echo $res->getBody();
    ```
  </CodeGroup>
</div>

<div>
  ## Company Domain to Name API in Go

  <CodeGroup>
    ```go Request theme={null}
    package main

    import (
    "fmt"
    "strings"
    "net/http"
    "io"
    )

    func main() {

    url := "https://api.companyurlfinder.com/v2/services/domain_to_name"
    method := "POST"

    payload := strings.NewReader("domain=ibm.com")

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
        fmt.Println(err)
        return
    }
    req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
    req.Header.Add("x-api-key", "your_api_key")

    res, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer res.Body.Close()

    body, err := io.ReadAll(res.Body)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(body))
    }
    ```
  </CodeGroup>
</div>

<div>
  ## Company Domain to Name API in Ruby

  <CodeGroup>
    ```ruby Request theme={null}
    require "uri"
    require "net/http"

    url = URI("https://api.companyurlfinder.com/v2/services/domain_to_name")

    https = Net::HTTP.new(url.host, url.port)
    https.use_ssl = true

    request = Net::HTTP::Post.new(url)
    request["Content-Type"] = "application/x-www-form-urlencoded"
    request["x-api-key"] = "your_api_key"
    request.body = "domain=ibm.com"

    response = https.request(request)
    puts response.read_body
    ```
  </CodeGroup>
</div>

<div>
  ## Company Domain to Name API in Kotlin

  <CodeGroup>
    ```kotlin Request theme={null}
    val client = OkHttpClient()
    val mediaType = "application/x-www-form-urlencoded".toMediaType()
    val body = "domain=ibm.com".toRequestBody(mediaType)
    val request = Request.Builder()
    .url("https://api.companyurlfinder.com/v2/services/domain_to_name")
    .post(body)
    .addHeader("Content-Type", "application/x-www-form-urlencoded")
    .addHeader("x-api-key", "your_api_key")
    .build()
    val response = client.newCall(request).execute()
    ```
  </CodeGroup>
</div>

<div>
  ## Company Domain to Name API in Java

  <CodeGroup>
    ```java Request theme={null}
    OkHttpClient client = new OkHttpClient().newBuilder().build();
    MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
    RequestBody body = RequestBody.create(mediaType, "domain=ibm.com");
    Request request = new Request.Builder()
    .url("https://api.companyurlfinder.com/v2/services/domain_to_name")
    .method("POST", body)
    .addHeader("Content-Type", "application/x-www-form-urlencoded")
    .addHeader("x-api-key", "your_api_key")
    .build();
    Response response = client.newCall(request).execute();
    ```
  </CodeGroup>
</div>


# Company Name to Domain API
Source: https://apidocs.companyurlfinder.com/apis/company-name-to-domain

Company websites power every B2B outreach campaign you run. Without verified domains, your lead lists sit there—useless. That's where Company URL Finder's Name to Domain API comes in.

**Company URL Finder** consistently delivers 95%+ accuracy across our database of 85M+ verified company records.
This API transforms incomplete CRM records into actionable intelligence that your sales team actually uses. It integrates into any workflow—**CRM** automation, lead qualification pipelines, real-time lookup systems, webhook triggers.

<div>
  <div>
    <div>
      <div>
        <Badge>post</Badge>
        <p>[https://api.companyurlfinder.com/v2/services/name\_to\_domain](https://api.companyurlfinder.com/v2/services/name_to_domain)</p>
      </div>
    </div>
  </div>

  <Badge icon="star">
    Credit usage is 1 per record found.
  </Badge>

  <div>
    <div>
      <div>
        ## Attributes

        <ParamField type="string">
          Your API key.
        </ParamField>

        <ParamField type="string">
          Company name
        </ParamField>

        <ParamField type="string">
          Country code

          <Note>
            Please note that when you set the country code, the results are limited to that country. For example, for the company name 'Nestlé' and the country 'Switzerland', we returned nestle.ch as a result.
          </Note>
        </ParamField>
      </div>
    </div>

    <div>
      <CodeGroup>
        ```bash Request theme={null}
        curl --location 'https://api.companyurlfinder.com/v2/services/name_to_domain' \
        --header 'Content-Type: application/x-www-form-urlencoded' \
        --header 'x-api-key: your_api_key' \
        --data-urlencode 'company_name=cufinder' \
        --data-urlencode 'country_code=US'
        ```

        ```javascript Request theme={null}
        const myHeaders = new Headers();
        myHeaders.append("Content-Type", "application/x-www-form-urlencoded");
        myHeaders.append("x-api-key", "your_api_key");

        const urlencoded = new URLSearchParams();
        urlencoded.append("company_name", "cufinder");
        urlencoded.append("country_code", "US");

        const requestOptions = {
            method: "POST",
            headers: myHeaders,
            body: urlencoded,
            redirect: "follow"
        };

        fetch("https://api.companyurlfinder.com/v2/services/name_to_domain", requestOptions)
            .then((response) => response.text())
            .then((result) => console.log(result))
            .catch((error) => console.error(error));
        ```

        ```python Request theme={null}
        import requests

        url = "https://api.companyurlfinder.com/v2/services/name_to_domain"

        payload = 'company_name=cufinder&country_code=US'
        headers = {
            'Content-Type': 'application/x-www-form-urlencoded',
            'x-api-key': 'your_api_key'
        }

        response = requests.request("POST", url, headers=headers, data=payload)

        print(response.text)
        ```

        ```php Request theme={null}
        $client = new Client();
        $headers = [
            'Content-Type' => 'application/x-www-form-urlencoded',
            'x-api-key' => 'your_api_key'
        ];
        $options = [
        'form_params' => [
            'company_name' => 'cufinder',
            'country_code' => 'US'
        ]];
        $request = new Request('POST', 'https://api.companyurlfinder.com/v2/services/name_to_domain', $headers);
        $res = $client->sendAsync($request, $options)->wait();
        echo $res->getBody();
        ```
      </CodeGroup>

      <CodeGroup>
        ```json Response theme={null}
        {
            "status": 1,
                "code": 1000,
                "errors": {},
                "data": {
                    "exists": true,
                    "domain": "cufinder.io",
                    "remaining_credits": 9999
                }
        }
        ```
      </CodeGroup>
    </div>
  </div>
</div>

<StatusCodes />

<div>
  ## Company Name to Domain API in Javascript

  <CodeGroup>
    ```javascript Request theme={null}
    const myHeaders = new Headers();
    myHeaders.append("Content-Type", "application/x-www-form-urlencoded");
    myHeaders.append("x-api-key", "your_api_key");

    const urlencoded = new URLSearchParams();
    urlencoded.append("company_name", "cufinder");
    urlencoded.append("country_code", "US");

    const requestOptions = {
        method: "POST",
        headers: myHeaders,
        body: urlencoded,
        redirect: "follow"
    };

    fetch("https://api.companyurlfinder.com/v2/services/name_to_domain", requestOptions)
        .then((response) => response.text())
        .then((result) => console.log(result))
        .catch((error) => console.error(error));
    ```
  </CodeGroup>
</div>

<div>
  ## Company Name to Domain API in Python

  <CodeGroup>
    ```python Request theme={null}
    import requests

    url = "https://api.companyurlfinder.com/v2/services/name_to_domain"

    payload = 'company_name=cufinder&country_code=US'
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded',
        'x-api-key': 'your_api_key'
    }

    response = requests.request("POST", url, headers=headers, data=payload)

    print(response.text)
    ```
  </CodeGroup>
</div>

<div>
  ## Company Name to Domain API in PHP

  <CodeGroup>
    ```php Request theme={null}
    $client = new Client();
    $headers = [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'x-api-key' => 'your_api_key'
    ];
    $options = [
    'form_params' => [
        'company_name' => 'cufinder',
        'country_code' => 'US'
    ]];
    $request = new Request('POST', 'https://api.companyurlfinder.com/v2/services/name_to_domain', $headers);
    $res = $client->sendAsync($request, $options)->wait();
    echo $res->getBody();
    ```
  </CodeGroup>
</div>

<div>
  ## Company Name to Domain API in Go

  <CodeGroup>
    ```go Request theme={null}
    package main

    import (
        "fmt"
        "strings"
        "net/http"
        "io"
    )

    func main() {

        url := "https://api.companyurlfinder.com/v2/services/name_to_domain"
        method := "POST"

        payload := strings.NewReader("company_name=cufinder&country_code=US")

        client := &http.Client {
        }
        req, err := http.NewRequest(method, url, payload)

        if err != nil {
        fmt.Println(err)
        return
        }
        req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
        req.Header.Add("x-api-key", "your_api_key")

        res, err := client.Do(req)
        if err != nil {
        fmt.Println(err)
        return
        }
        defer res.Body.Close()

        body, err := io.ReadAll(res.Body)
        if err != nil {
        fmt.Println(err)
        return
        }
        fmt.Println(string(body))
    }
    ```
  </CodeGroup>
</div>

<div>
  ## Company Name to Domain API in Ruby

  <CodeGroup>
    ```ruby Request theme={null}
    require "uri"
    require "net/http"

    url = URI("https://api.companyurlfinder.com/v2/services/name_to_domain")

    https = Net::HTTP.new(url.host, url.port)
    https.use_ssl = true

    request = Net::HTTP::Post.new(url)
    request["Content-Type"] = "application/x-www-form-urlencoded"
    request["x-api-key"] = "your_api_key"
    request.body = "company_name=cufinder&country_code=US"

    response = https.request(request)
    puts response.read_body
    ```
  </CodeGroup>
</div>

<div>
  ## Company Name to Domain API in Kotlin

  <CodeGroup>
    ```kotlin Request theme={null}
    val client = OkHttpClient()
    val mediaType = "application/x-www-form-urlencoded".toMediaType()
    val body = "company_name=cufinder&country_code=US".toRequestBody(mediaType)
    val request = Request.Builder()
        .url("https://api.companyurlfinder.com/v2/services/name_to_domain")
        .post(body)
        .addHeader("Content-Type", "application/x-www-form-urlencoded")
        .addHeader("x-api-key", "your_api_key")
        .build()
    val response = client.newCall(request).execute()
    ```
  </CodeGroup>
</div>

<div>
  ## Company Name to Domain API in Java

  <CodeGroup>
    ```java Request theme={null}
    OkHttpClient client = new OkHttpClient().newBuilder().build();
    MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
    RequestBody body = RequestBody.create(mediaType, "company_name=cufinder&country_code=US");
    Request request = new Request.Builder()
        .url("https://api.companyurlfinder.com/v2/services/name_to_domain")
        .method("POST", body)
        .addHeader("Content-Type", "application/x-www-form-urlencoded")
        .addHeader("x-api-key", "your_api_key")
        .build();
    Response response = client.newCall(request).execute();
    ```
  </CodeGroup>
</div>


# Errors
Source: https://apidocs.companyurlfinder.com/apis/errors

In this guide, we will talk about what happens when something goes wrong while you work with the API. Mistakes happen, and mostly they will be yours, not ours. Let's look at some status codes and error types you might encounter.

You can tell if your request was successful by checking the status code when receiving an API response. If a response comes back unsuccessful, you can use the error type and error message to figure out what has gone wrong and do some rudimentary debugging (before contacting support).

<Tip>
  <p>
    Before reaching out to support with an error, please be aware that 99% of all reported errors are, in fact, user errors. Therefore, please carefully check your code before contacting Company URL Finder support.
  </p>
</Tip>

<StatusCodes />

## Error types

<div>
  Whenever a request is unsuccessful, the Company URL Finder API will return an error response with an error type and message. You can use this information to understand better what has gone wrong and how to fix it. Most of the error messages are pretty helpful and actionable.

  Here is a list of the two error types supported by the Company URL Finder API — use these to understand what you have done wrong.

  <CodeGroup>
    ```json theme={null}
    {
      "type": "api_error",
      "message": "API key is wrong!"
    }
    ```
  </CodeGroup>

  <div>
    <ParamField type="string">
      This means that we made an error, which is highly speculative and unlikely.
    </ParamField>

    <ParamField type="string">
      This means that you made an error, which is much more likely.
    </ParamField>
  </div>
</div>


# LinkedIn Company URL Finder API
Source: https://apidocs.companyurlfinder.com/apis/linkedin-company-url-finder

LinkedIn company pages drive B2B research, sales prospecting, and competitive intelligence. Without verified LinkedIn URLs, your team wastes hours manually searching—or worse, lands on wrong profiles. That's where our LinkedIn Company URL Finder API comes in.

We matches company names against our database of 285M+ verified business records—returning accurate LinkedIn company page URLs with high confidence scores.

This API transforms basic company lists into LinkedIn-enriched datasets your sales and marketing teams can leverage instantly. It integrates into any workflow—CRM enrichment pipelines, ABM campaign builders, sales intelligence platforms, prospecting automation tools.

<div>
  <div>
    <div>
      <div>
        <Badge>post</Badge>
        <p>[https://api.companyurlfinder.com/v2/services/name\_to\_linkedin](https://api.companyurlfinder.com/v2/services/name_to_linkedin)</p>
      </div>
    </div>
  </div>

  <Badge icon="star">
    Credit usage is 1 per record found.
  </Badge>

  <div>
    <div>
      <div>
        ## Attributes

        <ParamField type="string">
          Your API key.
        </ParamField>

        <ParamField type="string">
          cufinder.io
        </ParamField>
      </div>
    </div>

    <div>
      <CodeGroup>
        ```bash Request theme={null}
        curl --location 'https://api.companyurlfinder.com/v2/services/name_to_linkedin' \
        --header 'Content-Type: application/x-www-form-urlencoded' \
        --header 'x-api-key: your_api_key' \
        --data-urlencode 'query=cufinder.io'
        ```

        ```javascript Request theme={null}
        const myHeaders = new Headers();
        myHeaders.append("Content-Type", "application/x-www-form-urlencoded");
        myHeaders.append("x-api-key", "your_api_key");

        const urlencoded = new URLSearchParams();
        urlencoded.append("query", "cufinder.io");

        const requestOptions = {
            method: "POST",
            headers: myHeaders,
            body: urlencoded,
            redirect: "follow"
        };

        try {
            const response = await fetch("https://api.companyurlfinder.com/v2/services/name_to_linkedin", requestOptions);
            const result = await response.text();
            console.log(result)
        } catch (error) {
            console.error(error);
        };
        ```

        ```python Request theme={null}
         import requests

        url = "https://api.companyurlfinder.com/v2/services/name_to_linkedin"

        payload = 'query=cufinder.io'
        headers = {
            'Content-Type': 'application/x-www-form-urlencoded',
            'x-api-key': 'your_api_key'
        }

        response = requests.request("POST", url, headers=headers, data=payload)

        print(response.text)
        ```

        ```php Request theme={null}
        $client = new Client();
        $headers = [
            'Content-Type' => 'application/x-www-form-urlencoded',
            'x-api-key' => 'your_api_key'
        ];
        $options = [
        'form_params' => [
            'query' => 'cufinder.io'
        ]];
        $request = new Request('POST', 'https://api.companyurlfinder.com/v2/services/name_to_linkedin', $headers);
        $res = $client->sendAsync($request, $options)->wait();
        echo $res->getBody();
        ```
      </CodeGroup>

      <CodeGroup>
        ```json Response theme={null}
        {
            "status": 1,
            "code": 1000,
            "errors": {},
            "data": {
                "exists": true,
                "linkedin_url": "linkedin.com/company/cufinder",
                "remaining_credits": 2984
            }
        }
        ```
      </CodeGroup>
    </div>
  </div>
</div>

<StatusCodes />

<div>
  ## Company LinkedIn Company URL Finder API in Javascript

  <CodeGroup>
    ```javascript Request theme={null}
    const myHeaders = new Headers();
    myHeaders.append("Content-Type", "application/x-www-form-urlencoded");
    myHeaders.append("x-api-key", "your_api_key");

    const urlencoded = new URLSearchParams();
    urlencoded.append("query", "cufinder.io");

    const requestOptions = {
        method: "POST",
        headers: myHeaders,
        body: urlencoded,
        redirect: "follow"
    };

    try {
        const response = await fetch("https://api.companyurlfinder.com/v2/services/name_to_linkedin", requestOptions);
        const result = await response.text();
        console.log(result)
    } catch (error) {
        console.error(error);
    };
    ```
  </CodeGroup>
</div>

<div>
  ## Company LinkedIn Company URL Finder API in Python

  <CodeGroup>
    ```python Request theme={null}
    import requests

    url = "https://api.companyurlfinder.com/v2/services/name_to_linkedin"

    payload = 'query=cufinder.io'
    headers = {
        'Content-Type': 'application/x-www-form-urlencoded',
        'x-api-key': 'your_api_key'
    }

    response = requests.request("POST", url, headers=headers, data=payload)

    print(response.text)
    ```
  </CodeGroup>
</div>

<div>
  ## Company LinkedIn Company URL Finder API in PHP

  <CodeGroup>
    ```php Request theme={null}
    $client = new Client();
    $headers = [
        'Content-Type' => 'application/x-www-form-urlencoded',
        'x-api-key' => 'your_api_key'
    ];
    $options = [
        'form_params' => [
        'query' => 'cufinder.io'
    ]];
    $request = new Request('POST', 'https://api.companyurlfinder.com/v2/services/name_to_linkedin', $headers);
    $res = $client->sendAsync($request, $options)->wait();
    echo $res->getBody();
    ```
  </CodeGroup>
</div>

<div>
  ## Company LinkedIn Company URL Finder API in Go

  <CodeGroup>
    ```go Request theme={null}
    package main

    import (
    "fmt"
    "strings"
    "net/http"
    "io"
    )

    func main() {

    url := "https://api.companyurlfinder.com/v2/services/name_to_linkedin"
    method := "POST"

    payload := strings.NewReader("query=cufinder.io")

    client := &http.Client {
    }
    req, err := http.NewRequest(method, url, payload)

    if err != nil {
        fmt.Println(err)
        return
    }
    req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
    req.Header.Add("x-api-key", "your_api_key")

    res, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer res.Body.Close()

    body, err := io.ReadAll(res.Body)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(body))
    }
    ```
  </CodeGroup>
</div>

<div>
  ## Company LinkedIn Company URL Finder API in Ruby

  <CodeGroup>
    ```ruby Request theme={null}
    require "uri"
    require "net/http"

    url = URI("https://api.companyurlfinder.com/v2/services/name_to_linkedin")

    https = Net::HTTP.new(url.host, url.port)
    https.use_ssl = true

    request = Net::HTTP::Post.new(url)
    request["Content-Type"] = "application/x-www-form-urlencoded"
    request["x-api-key"] = "your_api_key"
    request.body = "query=cufinder.io"

    response = https.request(request)
    puts response.read_body
    ```
  </CodeGroup>
</div>

<div>
  ## Company LinkedIn Company URL Finder API in Kotlin

  <CodeGroup>
    ```kotlin Request theme={null}
    val client = OkHttpClient()
    val mediaType = "application/x-www-form-urlencoded".toMediaType()
    val body = "query=cufinder.io".toRequestBody(mediaType)
    val request = Request.Builder()
    .url("https://api.companyurlfinder.com/v2/services/name_to_linkedin")
    .post(body)
    .addHeader("Content-Type", "application/x-www-form-urlencoded")
    .addHeader("x-api-key", "your_api_key")
    .build()
    val response = client.newCall(request).execute()
    ```
  </CodeGroup>
</div>

<div>
  ## Company LinkedIn Company URL Finder API in Java

  <CodeGroup>
    ```java Request theme={null}
    OkHttpClient client = new OkHttpClient().newBuilder().build();
    MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
    RequestBody body = RequestBody.create(mediaType, "query=cufinder.io");
    Request request = new Request.Builder()
    .url("https://api.companyurlfinder.com/v2/services/name_to_linkedin")
    .method("POST", body)
    .addHeader("Content-Type", "application/x-www-form-urlencoded")
    .addHeader("x-api-key", "your_api_key")
    .build();
    Response response = client.newCall(request).execute();
    ```
  </CodeGroup>
</div>


# Quick Start
Source: https://apidocs.companyurlfinder.com/apis/quick-start

This guide will get you all set up and ready to use the Company URL Finder API. We'll cover how to get started using one of our API endpoints and how to make your first API request. We'll also look at where to go next to find all the information you need to take full advantage of our powerful REST API.

<Tip>
  <p>
    Before you can make requests to the Company URL Finder API, you will need to grab your API key from your dashboard. You find it under

    <a href="https://companyurlfinder.com/login">
      Account » API key.
    </a>
  </p>
</Tip>

## What's next ?

Great, you're now access to your API key and can make your first request to the API. Presented here is the exhaustive list of APIs, accompanied by the instructions on how to call them.


# Usage Limits
Source: https://apidocs.companyurlfinder.com/apis/usage-limits

We define rate limits on a per-key basis and use a fixed-window rate limiting strategy. Our API key's rate limit is 100 requests per minute. It means, you can make 100 API calls at any interval within the 60-second window.

<br />