> ## Documentation Index
> Fetch the complete documentation index at: https://deepline.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# PredictLeads: Company Connections

> List a company's known business connections, such as partners, vendors, customers and investors, with when each was first seen.

List a company's known business connections, such as partners, vendors, customers and investors, with when each was first seen.

> [!NOTE]
>
> Tool ID: `predictleads_company_connections`

## Run this action

Use the TypeScript SDK for one call. Use `ctx.tools.execute(...)` inside a Play for durable calls, scheduled calls, or CSV processing.

```ts theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
import { Deepline } from 'deepline';

const deepline = await Deepline.connect();
const result = await deepline.tools.execute(
  'predictleads_company_connections',
  {
    "company_id_or_domain": "example.com"
  },
);

console.log(result.toolResponse.raw);
```

### CLI

```bash theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
deepline tools execute predictleads_company_connections --input '{
  "company_id_or_domain": "example.com"
}' --json
```

## Example response

The static output schema lacks the details for a reliable example. Use `deepline describe predictleads_company_connections --json` for the complete live contract.

## Input reference

Returns a list of company's Connections.

| Name | Type | Required | Default | Details |
| - | - | - | - | - |
| `payload.company_id_or_domain` | `string` | Yes | — | Company's ID or domain. |
| `payload.first_seen_at_from` | `string` | No | — | Only return `Connections` first seen after given date (ISO 8601). Format: `date`. |
| `payload.first_seen_at_until` | `string` | No | — | Only return `Connections` first seen before given date (ISO 8601). Format: `date`. |
| `payload.categories` | `array` | No | — | Comma-separated (,) `Connection` categories. |
| `payload.page` | `integer` | No | `1` | Page number of shown items. **NOTE**: If the parameter is not provided, the meta property `count` will be omitted from response for performance reasons. Minimum: 1. |
| `payload.limit` | `integer` | No | `100` | Limit the number of shown items per page. Maximum: 1000. |

<details>
  <summary>Show raw input schema</summary>

  ### Input JSON Schema

  ```json theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
  {
    "type": "object",
    "description": "Returns a list of company's Connections.",
    "properties": {
      "company_id_or_domain": {
        "type": "string",
        "description": "Company's ID or domain."
      },
      "first_seen_at_from": {
        "type": "string",
        "description": "Only return `Connections` first seen after given date (ISO 8601).",
        "format": "date"
      },
      "first_seen_at_until": {
        "type": "string",
        "description": "Only return `Connections` first seen before given date (ISO 8601).",
        "format": "date"
      },
      "categories": {
        "type": "array",
        "description": "Comma-separated (,) `Connection` categories.",
        "items": {
          "anyOf": [
            {
              "description": "**Read as**: Company1 is a partner of Company2. A partner relationship signals a collaboration between companies that goes both in two directions. You will find such connections using titles as \"We work with\", \"Our partners\", \"The company we keep\", and other titles similar in meaning. The implications of this category can be quite wide in their meaning, but in general all partnerships are a positive signal. **NOTE**: Until February 2024 the `partner` category did not always signal a true partnership between two companies, but it also included a tighter knit relationship compared to the `other` category, which are not always as strong as the partner keyword suggests. The meaning is now correctly followed for all new cases or cases that have been last seen since and still have the `partner` category.",
              "const": "partner"
            },
            {
              "description": "**Read as**: Company1 is a vendor to Company2. The vendor category is much simpler in its meaning. It simply means that company1 is a supplier for company2 in some way. All vendor relationships are positive, although some are more positive than others. On a webpage, such connections can be seen in lists such as \"Our customers\", \"Trusted by\", \"Enabling businesses to\", etc. For example, to be a vendor to Microsoft, the company has to pass certain requirements as to company size, product reliability, safety, etc. This can be seen as a vetting process of some sort and increases the company's trustworthiness. The vendor category can also be used to determine the supply chain of a certain company and evaluate supply chain risks.",
              "const": "vendor"
            },
            {
              "description": "**Read as**: Company1 has an integration with Company2. Most of the time an integration happens between a platform and a service. Case examples: Company1 has developed a Machine learning model. To make it more usable, they have developed an Azure Cloud integration. With this, the customers of the model can start using it more quickly, which is good for Company1. It's generally the service's development team that takes on the task of creating this integration. This can also be a positive signal for the platform (Company2). One could calculate the adoption of the Company2 platform and use this as a signal for growth.",
              "const": "integration"
            },
            {
              "description": "**Read as**: Company1 is an investor in Company2. The investor category identifies relationships between companies making investments (Company1) and companies receiving investments (Company2). The more investors the company has, the better. One could also track what companies/sectors competitors are investing in.",
              "const": "investor"
            },
            {
              "description": "**Read as**: Company1 is a parent company of Company2. Parent category defines a parent-subsidiary relationship between websites. In some cases such websites are only localized versions for specific markets. Case examples: \"activisionblizzard.com\" is a parent to \"blizzard.com\", and in turn \"blizzard.com\" is a parent to \"blizzard.de\". \"coca-cola.com\" is a parent to a vast array of websites, such as \"coca-cola.fr\", \"coca-cola.de\", \"coca-cola.es\", \"coca-cola.tn\", \"coca-cola.se\", etc. **NOTE**: Often it makes sense to not only check current hierarchy level e.g. \"blizzard.de\" but also check their parent connections e.g. \"blizzard.com\" and \"activisionblizzard.com\". Since sometimes company connections (customers, investors…) are also available at higher company hierarchical levels.",
              "const": "parent"
            },
            {
              "description": "**Read as**: Company1 is a rebranding of Company2. Company1 being a rebranding of Company2 suggests that Company2 has undergone a process to change its brand identity. We detect rebranding based on domain change and similarities between the old and the new website. Case examples: Top-level-domain (TLD) change: airmeet.co -> airmeet.com. airmeet.com is a rebranding of airmeet.co. TLD changed to higher value .com. Change to a shorter domain: lamborghini.com is a rebranding of lamborghini-madrid.com. Name change: hausarztpraxis-leinetal.de is a rebranding of praxis-schuenemann.de.",
              "const": "rebranding"
            },
            {
              "description": "**Read as**: Company1 is published in Company2. The `published_in` category is usually found on early stage startup websites with fewer accomplishments on the market, but positive press coverage. You can see such connections under titles such as \"As seen in\", \"Featured in\", \"Talking about us\", etc. A `published_in` connection is a positive signal, but after some months or years, we would expect to see them removed and replaced with other content proving the legitimacy of the company.",
              "const": "published_in"
            },
            {
              "description": "**Read as**: Company1 has a badge of Company2. The `badge` category shows that the Company1 has a certificate issued by the Company2 e.g. SOC 2 Type 2, ISO 27001, or some other common badges like GDPR, CCPA, etc. Such connections may have a TechnologyLite reference present, describing the technology in some detail. Full information about that technology is available via the technology endpoint.",
              "const": "badge"
            },
            {
              "description": "**Read as**: Company1 is connected to Company2. This is the most general category. If we detected a relationship between companies, but we were unsure which category it belonged to, or it didn't belong to any of our categories, then we would categorize it as `other`. Outgoing `other` category connections are a slightly positive signal, while incoming ones are quite more so. Thus a connection Company1 -> other -> Company2 is more positive for Company2, than for Company1. As Company2 was featured on Company1 website. Sometimes the `other` category can have additional information via the source_category attribute depending on where it was found. An example of such a source_category would be `cookie_section`, which is explained further below. Such connections could be evaluated differently.",
              "const": "other"
            }
          ]
        }
      },
      "page": {
        "type": "integer",
        "description": "Page number of shown items. **NOTE**: If the parameter is not provided, the meta property `count` will be omitted from response for performance reasons.",
        "default": 1,
        "minimum": 1
      },
      "limit": {
        "type": "integer",
        "description": "Limit the number of shown items per page.",
        "default": 100,
        "maximum": 1000
      }
    },
    "required": [
      "company_id_or_domain"
    ],
    "additionalProperties": false
  }
  ```
</details>

## Output reference

Standard tool result payload.

| Name | Type | Required | Default | Details |
| - | - | - | - | - |
| `result.data` | `object` | Yes | — | Since 2019, PredictLeads has detected over 230 million business connections between companies globally. The Company Connections Dataset describes relationships between some 48 million companies. Connections are sourced from Case Study pages, Testimonials, Our Customers sections, and is done through image recognition of company logos. The Connections Dataset includes fields such as Connection Category, Source Category, Source URL, Context, First Seen At, Last Seen At, and other Connection See the live schema for the complete constraint. |
| `result.data.data` | `array` | Yes | — | — |
| `result.data.data[].id` | `string` | Yes | — | ID of the `Connection` object. Format: `uuid`. |
| `result.data.data[].type` | `"connection"` | Yes | — | Type of the `Connection` object. |
| `result.data.data[].attributes` | `object` | Yes | — | Attributes of the `Connection` object. |
| `result.data.data[].attributes.category` | `"partner" \| "vendor" \| "integration" \| "investor" \| "parent" \| "rebranding" \| "published_in" \| "badge" \| "other"` | Yes | — | `Connection` category. |
| `result.data.data[].attributes.source_category` | `"undefined" \| "partner_page" \| "vendor_page" \| "integration_page" \| "investor_page" \| "about_page" \| "parent_page" \| "case_study_page" \| "testimonial_page" \| "manual_input" \| "domain_redirect" \| "same_subpage" \| "partner_section" \| "vendor_section" \| "integration_section" \| "investor_section" \| "parent_section" \| "case_study_section" \| "testimonial_section" \| "social_section" \| "published_in_section" \| "vendor_inverse_section" \| "investor_inverse_section" \| "parent_inverse_section" \| "footer" \| "header" \| "vendor_inverse_page" \| "cookie_section" \| "badge_section"` | Yes | — | Describes source where the `Connection` category was found. Allowed: `undefined`, `partner_page`, `vendor_page`, `integration_page`, `investor_page`, `about_page`, `parent_page`, `case_study_page`, `testimonial_page`, `manual_input`, `domain_redirect`, `same_subpage`, `partner_section`, `vendor_section`, `integration_section`, `investor_section`, `parent_section`, `case_study_section`, `testimonial_section`, `social_section`, `published_in_section`, `vendor_inverse_section`, See the live schema for the complete constraint. |
| `result.data.data[].attributes.source_url` | `null \| string` | Yes | — | URL where `Connection` information was found. Format: `uri`. |
| `result.data.data[].attributes.individual_source_url` | `null \| string` | Yes | — | URL where Connection`additional information was found. Format:`uri\`. |
| `result.data.data[].attributes.context` | `null \| string` | Yes | — | Text found near the connection. Often contains additional relationship information between the two companies. |
| `result.data.data[].attributes.first_seen_at` | `string` | Yes | — | Date & time (ISO 8601) of when the `Connection` was first seen. Format: `date-time`. |
| `result.data.data[].attributes.last_seen_at` | `string` | Yes | — | Date & time (ISO 8601) of when the `Connection` was last seen. Format: `date-time`. |
| `result.data.data[].relationships` | `object` | Yes | — | The data contains references to related objects listed in the `included` property. Order of companies is guaranteed and necessary to preserve the meaning of the `category`. For example: Company1 is a `vendor` to Company2. |
| `result.data.data[].relationships.company1` | `object` | Yes | — | The data contains a reference to related `CompanyLite` object listed in the `included` property. |
| `result.data.data[].relationships.company1.data` | `object` | Yes | — | — |
| `result.data.data[].relationships.company1.data.id` | `string` | Yes | — | ID of the included `CompanyLite` object. Format: `uuid`. |
| `result.data.data[].relationships.company1.data.type` | `"company"` | Yes | — | Type of the included `CompanyLite` object. |
| `result.data.data[].relationships.company2` | `object` | Yes | — | The data contains a reference to related `CompanyLite` object listed in the `included` property. |
| `result.data.data[].relationships.company2.data` | `object` | Yes | — | — |
| `result.data.data[].relationships.company2.data.id` | `string` | Yes | — | ID of the included `CompanyLite` object. Format: `uuid`. |
| `result.data.data[].relationships.company2.data.type` | `"company"` | Yes | — | Type of the included `CompanyLite` object. |
| `result.data.data[].relationships.technology` | `object` | Yes | — | The data contains a reference to related `TechnologyLite` object listed in the `included` property. |
| `result.data.data[].relationships.technology.data` | `object \| null` | Yes | — | — |
| `result.data.data[].relationships.technology.data.id` | `string` | Yes | — | ID of the included `TechnologyLite` object. Format: `uuid`. |
| `result.data.data[].relationships.technology.data.type` | `"technology"` | Yes | — | Type of the included `TechnologyLite` object. |
| `result.data.included` | `array` | Yes | — | Contains objects referenced in property `relationships`. |
| `result.data.meta` | `object` | No | — | Meta information about `ConnectionsDataset` object. |
| `result.data.meta.schema_version` | `string` | Yes | — | Represents schema version of objects. |
| `result.data.meta.record_state` | `"active"` | Yes | — | Represents record state of objects. |
| `result.data.meta.count` | `integer` | No | — | Total number of results. **NOTE**: Only included in API responses when the request parameter `page` is provided, for performance reasons. |
| `result.meta` | `object` | No | — | Additional response metadata (status, paging). |

> [!NOTE]
>
> This output schema is too large for an inline display. Read the complete live contract with `deepline describe predictleads_company_connections --json`.

## Deepline cost

* Pricing model: `fixed` (per call).
* Estimated Deepline credits: `0.56` per pricing unit.

## Related documentation

* [PredictLeads provider guide](https://deepline.com/docs/providers/predictleads/guide.md)
* [SDK V2 quickstart](https://deepline.com/docs/sdk-v2/quickstart.md)
* [SDK reference](https://deepline.com/docs/sdk-v2/sdk-reference.md)
* [Run tools across a CSV](https://deepline.com/docs/sdk-v2/batch-csv.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.