diff --git a/api-reference/enumerations/get-associated-domains.mdx b/api-reference/enumerations/get-associated-domains.mdx new file mode 100644 index 00000000..ed578eca --- /dev/null +++ b/api-reference/enumerations/get-associated-domains.mdx @@ -0,0 +1,74 @@ +--- +openapi: get /v1/domain/associated +--- + + +This endpoint discovers domains related to a given domain through multiple intelligence sources: acquisition history, certificate transparency logs, and WHOIS records. + +**Default Behavior:** When called without the `domain` parameter, returns associated domains for all your verified domains. Optionally provide a `domain` parameter to query associated domains for a specific domain. + +**Result Limits:** Results are limited to 10 associated domains per query. Enterprise plans include full results with pagination support. Contact [sales](https://projectdiscovery.io/request-demo) to access complete results. + + + +Retrieve your API key from [Settings → API Key](https://cloud.projectdiscovery.io/settings/api-key) in the ProjectDiscovery Cloud Platform. + + +## Discovery Sources + +The Associated Domains API correlates data from three primary sources: + +| Source | Description | +|--------|-------------| +| `acquisition_history` | Corporate subsidiaries and acquired companies from business intelligence sources | +| `certificate_history` | SSL/TLS certificate transparency logs revealing shared infrastructure | +| `whois_history` | Domain registration records identifying common ownership | + +## Example Requests + +### Get all associated domains + +```bash +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + +### Filter by specific source + +```bash +# Only certificate-based associations +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&source=certificate_history" \ + -H "X-Api-Key: YOUR_API_KEY" + +# Multiple sources +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&source=acquisition_history,whois_history" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + +### Filter by liveness + +```bash +# Only active/reachable domains +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&active=true" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + +### Paginated results + +```bash +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&limit=50&page=1&sort=subdomain_count" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + +### Raw output (plain text) + +```bash +# Get just domain names, one per line (useful for piping to other tools) +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&raw=true" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + +## Related Resources + +- [Associated Domains Discovery Guide](/cloud/assets/associated-domains) - Comprehensive feature documentation +- [Asset Discovery Overview](/cloud/assets/overview) - Platform asset management capabilities diff --git a/api-reference/introduction.mdx b/api-reference/introduction.mdx index 0ce29b39..55881d60 100644 --- a/api-reference/introduction.mdx +++ b/api-reference/introduction.mdx @@ -68,7 +68,7 @@ Below (and in the menu on the left) you can find the various resources available iconType="duotone" href="/api-reference/enumerations" > - Perform asset enumeration, manage asset groups, and track discovery history. + Perform asset enumeration, discover associated domains, manage asset groups, and track discovery history. +Need advanced workflows or custom domain discovery configurations? Our team can help set up enterprise-grade configurations tailored to your infrastructure. [Talk to our team](https://projectdiscovery.io/request-demo) to discuss your specific requirements. + + +Modern enterprises frequently have complex infrastructures spread across many domains and business units. ProjectDiscovery's **Associated Domains Discovery** gives security teams instant visibility into their entire organizational attack surface by automatically discovering related domains through multiple intelligence sources. + +The platform correlates data from **three primary sources**: +- **Acquisition History** - Corporate subsidiaries and acquired companies from business intelligence sources +- **Certificate History** - SSL/TLS certificate transparency logs revealing shared infrastructure +- **WHOIS History** - Domain registration records identifying common ownership + +This multi-source approach ensures comprehensive coverage, discovering domains that might be missed when relying on a single data source. + +--- + +## Why Associated Domains Discovery Matters + +Tracking assets across multiple organizations, subsidiaries, and technical infrastructures is notoriously difficult when done manually. Security teams traditionally had to compile lists of related domains from internal knowledge or public records, then run separate scans for each-a time-consuming and error-prone process. + +### Common Challenges + +- **Incomplete Visibility:** Large organizations might have dozens of related domains across subsidiaries, product brands, and acquired companies. Manually mapping all these entities is a huge challenge. In practice, many enterprises have hundreds or even thousands of related entities, making it difficult to get a clear picture of their full attack surface. + +- **Constant Change:** Mergers, acquisitions, and infrastructure changes mean the set of assets is constantly evolving. Without continuous updates, asset inventories become outdated quickly. Domains can change ownership or get spun up rapidly in cloud environments. + +- **Fragmented Data Sources:** Information about related domains is scattered across financial databases, certificate logs, WHOIS records, and press releases. Mapping out which domains are owned by your organization requires extensive research across multiple sources. + +- **Risk of Unknown Assets:** Unknown or unmanaged assets can lead to security incidents. A forgotten website under an acquired company or a domain sharing your SSL certificate could become an easy target for attackers. + +--- + +## Discovery Sources + +Associated Domains Discovery leverages three distinct intelligence sources, each providing unique insights into domain relationships. + +### Acquisition History + + **Source: Business Intelligence & Corporate Records** + +ProjectDiscovery integrates with corporate intelligence sources to automatically identify subsidiaries, acquired companies, and related brands associated with your organization. + +**What it discovers:** +- Subsidiary companies and their domains +- Acquired company assets +- Related brands and product domains +- Corporate hierarchy relationships + +**Evidence provided:** +| Field | Description | +|-------|-------------| +| `acquired_company` | Name of the acquired company | +| `acquired_date` | Date of acquisition | +| `acquirer_name` | Parent organization name | +| `source_url` | Link to source information | + +When you onboard to the platform, it automatically pulls known subsidiaries and related entities-giving you an instant snapshot of your organization's broad footprint without manual research. + +### Certificate History + + **Source: Certificate Transparency Logs** + +SSL/TLS certificates often reveal domain relationships that aren't visible through other means. Organizations frequently use shared certificates across related properties, or certificate organization fields expose ownership. + +**What it discovers:** +- Domains sharing the same SSL certificate +- Domains with matching certificate organization names +- Wildcard certificate coverage +- Certificate authority patterns + +**Evidence provided:** +| Field | Description | +|-------|-------------| +| `cert_common_name` | Certificate common name (CN) | +| `cert_org_name` | Organization name in certificate | +| `cert_issuer` | Certificate authority | +| `cert_serial` | Certificate serial number | +| `cert_issued_date` | When certificate was issued | +| `cert_expiry_date` | Certificate expiration date | + +### WHOIS History + + **Source: Domain Registration Records** + +WHOIS records provide authoritative information about domain ownership. By analyzing registration patterns, the platform identifies domains that share organizational ownership. + +**What it discovers:** +- Domains with matching registrant organizations +- Shared registrar patterns +- Common registration dates (bulk registrations) +- Related WHOIS contact information + +**Evidence provided:** +| Field | Description | +|-------|-------------| +| `registrant_org` | Registrant organization name | +| `registrar` | Domain registrar | +| `registration_date` | Domain registration date | +| `expiry_date` | Domain expiration date | +| `whois_server` | WHOIS server used | +| `orgname` | WHOIS organization name | + +--- + +## Using Associated Domains Discovery + +### Via the Platform UI + +Access [Associated Domains](https://cloud.projectdiscovery.io/assets/domains) in the platform to view domains related to your verified domains. By default, the platform automatically discovers and displays associated domains for all your verified domains. + +1. Navigate to **Assets** → **Domains** in the left sidebar +2. View associated domains automatically discovered for your verified domains +3. Optionally search for a specific domain to explore its associations +4. Review results grouped by discovery source +5. Add discovered domains to your asset inventory for monitoring + +### Via the API + +Query associated domains programmatically using the [Associated Domains API](/api-reference/enumerations/get-associated-domains). + +**Default behavior** - Returns associated domains for all your verified domains: + +```bash +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + +**Query specific domain** - Optionally specify a domain to get its associated domains: + +```bash +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + +**Filter by source:** + +```bash +# Only acquisition history +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&source=acquisition_history" \ + -H "X-Api-Key: YOUR_API_KEY" + +# Only certificate history +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&source=certificate_history" \ + -H "X-Api-Key: YOUR_API_KEY" + +# Multiple sources +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&source=certificate_history,whois_history" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + +**Filter by liveness:** + +```bash +# Only active/reachable domains +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&active=true" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + +**Pagination and sorting:** + +```bash +# Paginated results sorted by subdomain count +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&limit=50&page=1&sort=subdomain_count" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + +**Raw output (plain text):** + +```bash +# Get just domain names, one per line +curl -X GET "https://api.projectdiscovery.io/v1/domain/associated?domain=meta.com&raw=true" \ + -H "X-Api-Key: YOUR_API_KEY" +``` + + +Associated Domains Discovery returns up to 10 results per query on standard plans. [Upgrade to Enterprise](https://projectdiscovery.io/pricing) for complete associated domain discovery results. + + +--- + +## Response Structure + +The API returns comprehensive information about each discovered domain: + +```json +{ + "domain": "meta.com", + "sources": ["acquisition_history", "certificate_history", "whois_history"], + "sources_count": { + "acquisition_history": 5, + "certificate_history": 12, + "whois_history": 8 + }, + "unique_count": 18, + "results": [ + { + "domain": "subsidiary.com", + "sources": ["acquisition_history"], + "evidence": { + "acquired_company": "Subsidiary Inc", + "acquired_date": "2023-06-15", + "acquirer_name": "Meta", + "active": true, + "subdomain_count": 45, + "status_code": 200, + "title": "Subsidiary Inc - Homepage" + } + }, + { + "domain": "example-cdn.com", + "sources": ["certificate_history"], + "evidence": { + "cert_common_name": "*.meta.com", + "cert_org_name": "Meta Platforms, Inc.", + "cert_issuer": "DigiCert Inc", + "cert_issued_date": "2024-01-15", + "cert_expiry_date": "2025-01-15", + "active": true, + "subdomain_count": 3 + } + }, + { + "domain": "example-backup.com", + "sources": ["whois_history"], + "evidence": { + "registrant_org": "Meta Platforms, Inc.", + "registrar": "GoDaddy", + "registration_date": "2020-03-10", + "expiry_date": "2025-03-10", + "active": false + } + } + ] +} +``` + +### Key Response Fields + +| Field | Description | +|-------|-------------| +| `domain` | The queried domain | +| `sources` | List of all sources used in the query | +| `sources_count` | Number of results from each source | +| `unique_count` | Total unique associated domains found | +| `results` | Array of discovered domains with evidence | + +### Per-Result Fields + +| Field | Description | +|-------|-------------| +| `domain` | The associated domain name | +| `sources` | Which sources identified this domain | +| `evidence` | Source-specific proof of association | +| `evidence.active` | Whether the domain is currently reachable | +| `evidence.subdomain_count` | Number of known subdomains | +| `evidence.status_code` | HTTP status code (if probed) | +| `evidence.title` | HTTP page title (if available) | + +--- + +## Best Practices + +### Maximize Discovery Coverage + +1. **Use all sources:** Don't filter by source initially-let the platform correlate across all three sources for maximum coverage. + +2. **Check inactive domains:** Domains marked as `active: false` may still be valuable-they could be parked domains or temporarily down services that attackers might target. + +3. **Review subdomain counts:** High subdomain counts often indicate active infrastructure worth investigating further. + +### Integrate into Your Workflow + +1. **Automate discovery:** Use the API to periodically query associated domains and automatically add new discoveries to your asset inventory. + +2. **Set up alerts:** Configure notifications when new associated domains are discovered to stay ahead of your expanding attack surface. + +3. **Cross-reference with scans:** Run vulnerability scans on newly discovered domains to identify exposure before attackers do. + +### Handle Multi-Organization Environments + +1. **Start with your primary domain:** Query your main corporate domain first to establish the baseline. + +2. **Iterate on discoveries:** Query significant discovered domains to find second-degree associations. + +3. **Validate ownership:** Before adding domains to your scanning scope, verify ownership to avoid scanning third-party infrastructure. + +--- + +## Continuous Enrichment + +Associated Domains Discovery is not a one-time static pull. The platform continuously enhances its correlation capabilities: + +- **Real-time certificate monitoring:** New certificates are indexed as they appear in transparency logs +- **WHOIS update tracking:** Registration changes are detected and reflected in results +- **Acquisition intelligence:** Corporate events are tracked and correlated with domain ownership +- **Liveness probing:** Domain reachability is regularly checked and updated + +As your organization grows-launching new websites, spinning up cloud services, or acquiring companies-the platform automatically updates discoveries and keeps track of new potential entry points. + +--- + +## API Reference + +For complete API documentation including all parameters, response schemas, and code examples in multiple languages, see the [Associated Domains API Reference](/api-reference/enumerations/get-associated-domains). diff --git a/cloud/assets/overview.mdx b/cloud/assets/overview.mdx index bd35df6e..7e93e721 100644 --- a/cloud/assets/overview.mdx +++ b/cloud/assets/overview.mdx @@ -46,11 +46,18 @@ Our next‑generation asset discovery platform is built on a revolutionary three Automatically discover and track all external-facing and internal assets using integrated tools like Subfinder, Naabu, Httpx, and more - Configure patterns to exclude specific targets from discovery using subdomains, IPs, or wildcard patterns + Discover related domains through acquisitions, certificates, and WHOIS records + + + Native integration with major cloud providers for comprehensive asset discovery - Automatically map and manage assets across multiple subsidiaries and brands - - - Native integration with major cloud providers for comprehensive asset discovery - - - Seamless integration with Nuclei-powered scanning for comprehensive security assessment + Configure patterns to exclude specific targets from discovery using subdomains, IPs, or wildcard patterns diff --git a/cloud/assets/subsidiary.mdx b/cloud/assets/subsidiary.mdx deleted file mode 100644 index b3d6568a..00000000 --- a/cloud/assets/subsidiary.mdx +++ /dev/null @@ -1,41 +0,0 @@ ---- -title: 'Subsidiary & Multi-Organization Management' -description: 'Discover and manage assets across multiple organizations, subsidiaries, and brands' -sidebarTitle: 'Subsidiary Management' ---- - - -Need advanced workflows or custom subsidiary management? Our team can help set up enterprise-grade configurations tailored to your infrastructure. [Talk to our team](https://projectdiscovery.io/request-demo) to discuss your specific requirements. - - -Modern enterprises frequently have complex infrastructures spread across many domains and business units. ProjectDiscovery's platform is designed to give security teams **instant visibility into the entire organizational attack surface**, including assets belonging to subsidiaries, acquired companies, and separate brands. It does so by automating asset discovery and correlation on a global scale. The platform acts as a centralized inventory where all web properties, cloud resources, and external facing systems tied to an organization are cataloged together, regardless of which subsidiary or team they belong to. - -ProjectDiscovery built its cloud platform with **end-to-end exposure management workflows** that continuously discover assets and monitor them in real-time. This means as your organization grows – launching new websites, spinning up cloud services, or acquiring companies – the platform automatically updates your asset inventory and keeps track of new potential entry points. In short, ProjectDiscovery provides a *"single pane of glass"* for enterprise security teams to oversee multi-organization infrastructures. - -## Challenges in Traditional Subsidiary Asset Discovery - -Tracking assets across multiple organizations or subsidiaries is notoriously difficult when done manually. Security teams traditionally had to compile lists of subsidiary domains and networks from internal knowledge or public records, then run separate scans for each – a time-consuming and error-prone process. Some common challenges include: - -- **Incomplete Visibility:** Large organizations might have dozens of subsidiaries or brand domains, and each may host numerous applications. Manually mapping all these entities is a huge challenge. In practice, many enterprises have "hundreds or even thousands of related entities," making it *"difficult to get a clear picture of their full attack surface"*. Important assets can be overlooked simply because they were not on the main corporate domain. - -- **Constant Change:** Mergers, acquisitions, and divestitures mean the set of assets is constantly evolving. Without continuous updates, asset inventories become outdated quickly. IP addresses and domains can change ownership or get spun up and down rapidly in cloud environments. Keeping track of these changes manually is untenable. - -- **Fragmented Data Sources:** Information about subsidiaries is often scattered (e.g. in financial databases, press releases, WHOIS records). As a result, mapping out which domains or systems are owned by your company (versus third parties) can require extensive research. This fragmentation leads to **blind spots** in security monitoring. - -- **Risk of Unknown Assets:** Perhaps the biggest risk is that **unknown or unmanaged assets can lead to security incidents**. If a security team is only monitoring the primary organization's domains, a forgotten website under a subsidiary could become an easy target. As one security engineer described, without a centralized view "*new assets could pop up without our knowledge, creating potential vulnerabilities like subdomain takeovers*". In other words, attackers might exploit an obscure subsidiary's forgotten cloud bucket or an old acquisition's server if the defenders aren't even aware it exists. - -These challenges mean that traditional approaches (spreadsheets of subsidiaries, manual scans, etc.) often fail to provide complete coverage. Security teams end up reactive – finding out about a subsidiary's exposure only after an incident or external report. Clearly, a more automated, scalable solution is needed for subsidiary and multi-organization asset management. - -## How ProjectDiscovery Solves This Problem - -ProjectDiscovery's platform introduces automated features that **eliminate the manual legwork** of subsidiary asset discovery. It leverages external data and intelligent correlation to map out an enterprise's entire digital footprint across all related organizations, with minimal user input. Key capabilities include: - -- **Automated Subsidiary Correlation:** ProjectDiscovery integrates with the Crunchbase API to automatically identify which companies and domains are associated with your organization. As soon as you onboard, the platform pulls in known subsidiaries and related entities from Crunchbase's extensive corporate database. This means security teams *immediately* see a list of subsidiaries and their known domains without having to manually research corporate filings or news articles. By using this external intelligence, ProjectDiscovery can **map subsidiaries to assets** and help track associated assets across [your] entire corporate structure. - -- **Seamless Onboarding of Subsidiary Assets:** The platform presents this extended view during onboarding – giving users an instant snapshot of their organization's broad footprint as they set up their account. Instead of starting with a blank slate, an enterprise user logging into ProjectDiscovery for the first time might immediately see that the platform has identified, for example, _"SubsidiaryX.com, SubsidiaryY.net, and BrandZ.com"_ as belonging to their company. This **jump-starts the asset inventory** by automatically including the web properties of all child organizations. Such visibility, right at onboarding, ensures no major branch of the business is initially overlooked. - -- **Recognition of Brands and Owned Domains:** Subsidiary discovery in ProjectDiscovery isn't limited to exact company names – it also helps surface related domains or brands. For example, if your organization owns multiple product brands each with their own website, the platform can recognize those as part of your attack surface. It correlates various clues (DNS records, SSL certificates, WHOIS info, etc.) to cluster assets by ownership. As a result, security teams get a unified view of everything "owned" by the broader organization, even if operated under different names. - -- **Continuous Enrichment and Updates:** ProjectDiscovery's asset correlation is not a one-time static pull. It is continuously being enhanced. Upcoming improvements will use **reverse WHOIS lookups** to find additional owned domains and associated entities that might not be obvious from corporate listings. This will further expand coverage by catching assets that share registration details or contact emails with the organization. The platform is also opening up these discovery capabilities via API for the community, so its subsidiary detection engine will keep getting smarter over time. For the security team, this means the asset inventory grows and updates automatically as new information surfaces – without manual effort. - -By automating subsidiary and multi-organization asset discovery, ProjectDiscovery **saves countless hours** of manual mapping and drastically reduces the chances of missing a part of your attack surface. Security teams no longer need to maintain separate inventories or perform ad-hoc research whenever the company expands; the platform handles it for them in the background. All assets across the parent company and its subsidiaries funnel into one consolidated inventory for monitoring. \ No newline at end of file diff --git a/mint.json b/mint.json index 3d9fb181..b9fa61f8 100644 --- a/mint.json +++ b/mint.json @@ -384,18 +384,18 @@ "cloud/ossvscloud", "cloud/integrations", { - "group": "Assets", + "group": "Asset Discovery", "icon": "bullseye", "iconType": "regular", "pages": [ "cloud/assets/overview", + "cloud/assets/associated-domains", "cloud/assets/adding-assets", "cloud/assets/screenshots", "cloud/assets/labeling", "cloud/assets/custom-labeling", "cloud/assets/grouping", - "cloud/assets/exclusions", - "cloud/assets/subsidiary" + "cloud/assets/exclusions" ] }, { @@ -542,6 +542,7 @@ { "group": "Asset Discovery", "pages": [ + "api-reference/enumerations/get-associated-domains", "api-reference/enumerations/get-enumeration-list", "api-reference/enumerations/create-enumeration", "api-reference/enumerations/delete-assets-in-bulk", diff --git a/openapi.yaml b/openapi.yaml index ba14c93b..b5914b7f 100644 --- a/openapi.yaml +++ b/openapi.yaml @@ -10183,6 +10183,66 @@ paths: in: query name: scope description: Scope of search + /v1/domain/associated: + get: + summary: Get Associated Domains + description: Discover domains related to a given domain through acquisition history, certificate transparency logs, and WHOIS records. Returns associated domains with evidence of their relationship. + tags: + - enumerations + responses: + '200': + $ref: '#/components/responses/AssociatedDomainsResults' + '400': + $ref: '#/components/responses/ErrorResponse' + '401': + $ref: '#/components/responses/ErrorResponse' + '500': + $ref: '#/components/responses/ErrorResponse' + default: + $ref: '#/components/responses/ErrorResponse' + operationId: associated-domains + parameters: + - schema: + type: string + in: query + name: domain + description: Domain name to fetch associated domains. If omitted, returns associated domains for all your verified domains. + - schema: + type: string + in: query + name: source + description: 'Comma-separated source filter (acquisition_history, certificate_history, whois_history)' + - schema: + type: boolean + in: query + name: active + description: 'Filter by liveness (true=alive, false=unreachable)' + - schema: + type: string + enum: + - active + - domain + - source + - subdomain_count + - update_date + in: query + name: sort + description: Sort results by field + - schema: + type: integer + in: query + name: limit + description: 'Maximum results per page (pagination). If omitted, returns all.' + - schema: + type: integer + in: query + name: page + description: 'Page number (pagination, starts at 1)' + - schema: + type: boolean + in: query + name: raw + description: 'If true, returns plain text list (one domain per line)' /v1/organization/search: get: summary: Get Organization by Domain @@ -16645,6 +16705,149 @@ components: - organization - domain type: string + AssociatedDomainEvidence: + title: AssociatedDomainEvidence + type: object + description: Evidence supporting the domain association from various sources + properties: + acquired_company: + description: Acquired company name (acquisition_history source) + type: string + acquired_date: + description: Acquisition date (acquisition_history source) + type: string + acquirer_name: + description: Acquirer organization name (acquisition_history source) + type: string + active: + description: Whether the domain is currently reachable + type: boolean + as_name: + description: Autonomous system name + type: string + as_number: + description: Autonomous system number + type: integer + cert_common_name: + description: Certificate common name (certificate_history source) + type: string + cert_expiry_date: + description: Certificate expiry date (certificate_history source) + type: string + cert_issued_date: + description: Certificate issued date (certificate_history source) + type: string + cert_issuer: + description: Certificate issuer (certificate_history source) + type: string + cert_org_name: + description: Certificate organization name (certificate_history source) + type: string + cert_serial: + description: Certificate serial number (certificate_history source) + type: string + expiry_date: + description: Domain expiry date (whois_history source) + type: string + location: + description: Geographic location + type: string + orgname: + description: WHOIS organization name (whois_history source) + type: string + probe: + description: Probe information + type: string + registrant_org: + description: Registrant organization (whois_history source) + type: string + registrar: + description: Registrar name (whois_history source) + type: string + registration_date: + description: Domain registration date (whois_history source) + type: string + search_identifier: + description: Search identifier + type: string + source_url: + description: URL to source information + type: string + status_code: + description: HTTP status code from probe + type: integer + subdomain_count: + description: Number of discovered subdomains + type: integer + title: + description: HTTP page title from probe + type: string + update_date: + description: Last update date + type: string + whois_server: + description: WHOIS server (whois_history source) + type: string + AssociatedDomainResult: + title: AssociatedDomainResult + type: object + description: A single associated domain with its discovery sources and evidence + required: + - domain + - sources + properties: + domain: + description: The associated domain name + type: string + evidence: + $ref: '#/components/schemas/AssociatedDomainEvidence' + sources: + description: Sources that reported the association (acquisition_history, certificate_history, whois_history) + type: array + items: + type: string + AssociatedDomainsResultSet: + title: AssociatedDomainsResultSet + type: object + description: Complete response for associated domains query + required: + - domain + - results + - sources + properties: + domain: + description: The queried domain + type: string + results: + description: List of associated domains with evidence + type: array + items: + $ref: '#/components/schemas/AssociatedDomainResult' + sources: + description: List of sources used in the query + type: array + items: + type: string + sources_count: + description: Count of results per source + type: object + additionalProperties: + type: integer + unique_count: + description: Unique associated domains count + type: integer + limit: + description: Maximum results per page when paginated + type: integer + page: + description: Current page when paginated + type: integer + total_count: + description: Total associated domains when paginated + type: integer + total_pages: + description: Total pages when paginated + type: integer OpenVulnerabilityScoreMetrics: title: OpenVulnerabilityScoreMetrics type: object @@ -19386,6 +19589,16 @@ components: $ref: '#/components/schemas/OrganizationFullInfo' total: type: integer + AssociatedDomainsResults: + description: Associated domains response with evidence from multiple sources + content: + application/json: + schema: + $ref: '#/components/schemas/AssociatedDomainsResultSet' + text/plain: + schema: + type: string + description: Plain text list of domains when raw=true UpdateSharedTemplateResponse: description: Example response content: