Cloudmersive

Cloudmersive Domain API

Domain operations of the Cloudmersive Validate API — 12 operation(s) served from https://api.cloudmersive.com and authenticated with the Apikey header. One Cloudmersive API key grants access to every API in the portfolio.

GitHub OpenAPI

Operations 12

POST /validate/domain/check Validate a domain name #
POST /validate/domain/quality-score Validate a domain name's quality score #
POST /validate/domain/whois Get WHOIS information for a domain #
POST /validate/domain/url/syntax-only Validate a URL syntactically #
POST /validate/domain/url/full Validate a URL fully #
POST /validate/domain/url/get-top-level-domain Get top-level domain name from URL #
POST /validate/domain/url/phishing-threat-check Check a URL for Phishing threats #
POST /validate/domain/url/is-admin-path Check if path is a high-risk or vulnerable server administration path #
POST /validate/domain/url/safety-threat-check Check a URL for safety threats #
POST /validate/domain/url/ssrf-threat-check Check a URL for SSRF threats #
POST /validate/domain/url/ssrf-threat-check/batch Check a URL for SSRF threats in batches #
POST /validate/domain/url/ssrf-threat-check/html-embedded Check a URL for HTML embedded SSRF threats #

Documentation

📖
Documentation
https://api.cloudmersive.com/docs/validate.asp
📖
APIReference
https://api-console.cloudmersive.com/swagger/index.html?urls.primaryName=Validate%20API

Specifications

⚙
OpenAPI
https://artifacts.apis.io/cloudmersive/openapi/cloudmersive-domain-api-openapi.yml
⚙
OpenAPI
https://api.cloudmersive.com/validate/docs/v1/swagger

Schemas & Data

📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-whois-response-schema.json
📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-validate-url-response-full-schema.json
📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-phishing-check-response-schema.json
📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-url-safety-check-response-full-schema.json
📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-validate-url-response-syntax-only-schema.json
📊
JSONSchema
https://artifacts.apis.io/cloudmersive/json-schema/cloudmersive-url-ssrf-request-full-schema.json

Work with this as data

Every API here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for apis

7 MCP tools reach this
  • find_apisBrowse and filter every API in the catalog.
  • get_api_artifactsOne API's artifacts, grouped by type.
  • get_openapiThe primary OpenAPI for this API.
  • find_similar_apisAPIs that look like this one.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This API 
curl "https://apis.io/api/v1/apis/cloudmersive:cloudmersive-domain-api"
All apis 
curl "https://apis.io/api/v1/apis?limit=25"

Calls without X-API-Key need no key. Calls with it need a paid plan — get a key.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

GitHub Google LinkedIn

A second provider on the same verified email joins the account you already have.

OpenAPI Specification

cloudmersive-domain-api-openapi.yml Raw ↑ 
openapi: 3.2.0
info:
  version: v1
  title: validateapi Domain API
  description: The validation APIs help you validate data. Check if an E-mail address is real. Check if a domain is real. Check up on an IP address, and even where it is located. All this and much more is available in the validation API.
servers:
- url: http://localhost
tags:
- name: Domain
paths:
  /validate/domain/check:
    post:
      tags:
      - Domain
      summary: Validate a domain name
      description: Check whether a domain name is valid or not. API performs a live validation by contacting DNS services to validate the existence of the domain name.
      operationId: Domain_Check
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CheckResponse'
            text/json:
              schema:
                $ref: '#/components/schemas/CheckResponse'
            application/xml:
              schema:
                $ref: '#/components/schemas/CheckResponse'
            text/xml:
              schema:
                $ref: '#/components/schemas/CheckResponse'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              type: string
          text/json:
            schema:
              type: string
        description: Domain name to check, for example "cloudmersive.com".  The input is a string so be sure to enclose it in double-quotes.
        required: true
  /validate/domain/quality-score:
    post:
      tags:
      - Domain
      summary: Validate a domain name's quality score
      description: Check the quality of a domain name. Supports over 9 million domain names. Higher quality scores indicate more trust and authority in the domain name, with values ranging from 0.0 (low quality) to 10.0 (maximum quality).
      operationId: Domain_QualityScore
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DomainQualityResponse'
            text/json:
              schema:
                $ref: '#/components/schemas/DomainQualityResponse'
            application/xml:
              schema:
                $ref: '#/components/schemas/DomainQualityResponse'
            text/xml:
              schema:
                $ref: '#/components/schemas/DomainQualityResponse'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              type: string
          text/json:
            schema:
              type: string
        description: Domain name to check, for example "cloudmersive.com".
        required: true
  /validate/domain/whois:
    post:
      tags:
      - Domain
      summary: Get WHOIS information for a domain
      description: Validate whether a domain name exists, and also return the full WHOIS record for that domain name. WHOIS records include all the registration details of the domain name, such as information about the domain's owners.
      operationId: Domain_Post
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WhoisResponse'
            text/json:
              schema:
                $ref: '#/components/schemas/WhoisResponse'
            application/xml:
              schema:
                $ref: '#/components/schemas/WhoisResponse'
            text/xml:
              schema:
                $ref: '#/components/schemas/WhoisResponse'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              type: string
          text/json:
            schema:
              type: string
        description: Domain name to check, for example "cloudmersive.com".   The input is a string so be sure to enclose it in double-quotes.
        required: true
  /validate/domain/url/syntax-only:
    post:
      tags:
      - Domain
      summary: Validate a URL syntactically
      description: Validate whether a URL is syntactically valid (does not check endpoint for validity). Accepts various types of input and produces a well-formed URL as output.
      operationId: Domain_UrlSyntaxOnly
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseSyntaxOnly'
            text/json:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseSyntaxOnly'
            application/xml:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseSyntaxOnly'
            text/xml:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseSyntaxOnly'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ValidateUrlRequestSyntaxOnly'
          text/json:
            schema:
              $ref: '#/components/schemas/ValidateUrlRequestSyntaxOnly'
        description: Input URL information
        required: true
  /validate/domain/url/full:
    post:
      tags:
      - Domain
      summary: Validate a URL fully
      description: Validate whether a URL is syntactically valid (does not check endpoint for validity), whether it exists, and whether the endpoint is up and passes virus scan checks. Accepts various types of input and produces a well-formed URL as output.
      operationId: Domain_UrlFull
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseFull'
            text/json:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseFull'
            application/xml:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseFull'
            text/xml:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseFull'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ValidateUrlRequestFull'
          text/json:
            schema:
              $ref: '#/components/schemas/ValidateUrlRequestFull'
        description: Input URL request
        required: true
  /validate/domain/url/get-top-level-domain:
    post:
      tags:
      - Domain
      summary: Get top-level domain name from URL
      description: Gets the top-level domain name from a URL, such as mydomain.com.
      operationId: Domain_GetTopLevelDomainFromUrl
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseSyntaxOnly'
            text/json:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseSyntaxOnly'
            application/xml:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseSyntaxOnly'
            text/xml:
              schema:
                $ref: '#/components/schemas/ValidateUrlResponseSyntaxOnly'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ValidateUrlRequestSyntaxOnly'
          text/json:
            schema:
              $ref: '#/components/schemas/ValidateUrlRequestSyntaxOnly'
        description: Input URL information
        required: true
  /validate/domain/url/phishing-threat-check:
    post:
      tags:
      - Domain
      summary: Check a URL for Phishing threats
      description: Checks if an input URL is at risk of being an Phishing (fake login page, or other page designed to collect information via social engineering) threat or attack.
      operationId: Domain_PhishingCheck
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PhishingCheckResponse'
            text/json:
              schema:
                $ref: '#/components/schemas/PhishingCheckResponse'
            application/xml:
              schema:
                $ref: '#/components/schemas/PhishingCheckResponse'
            text/xml:
              schema:
                $ref: '#/components/schemas/PhishingCheckResponse'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/PhishingCheckRequest'
          text/json:
            schema:
              $ref: '#/components/schemas/PhishingCheckRequest'
        description: Input URL request
        required: true
  /validate/domain/url/is-admin-path:
    post:
      tags:
      - Domain
      summary: Check if path is a high-risk or vulnerable server administration path
      description: Check if the input URL or relative path is a server Administration Path, and therefore a risk or vulnerability for remote access.
      operationId: Domain_IsAdminPath
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/IsAdminPathResponse'
            text/json:
              schema:
                $ref: '#/components/schemas/IsAdminPathResponse'
            application/xml:
              schema:
                $ref: '#/components/schemas/IsAdminPathResponse'
            text/xml:
              schema:
                $ref: '#/components/schemas/IsAdminPathResponse'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              type: string
          text/json:
            schema:
              type: string
        description: URL or relative path to check, e.g. "/admin/login".  The input is a string so be sure to enclose it in double-quotes.
        required: true
  /validate/domain/url/safety-threat-check:
    post:
      tags:
      - Domain
      summary: Check a URL for safety threats
      description: Checks if an input URL is at risk of being a safety threat through malware, unwanted software, or social engineering threats.
      operationId: Domain_SafetyCheck
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UrlSafetyCheckResponseFull'
            text/json:
              schema:
                $ref: '#/components/schemas/UrlSafetyCheckResponseFull'
            application/xml:
              schema:
                $ref: '#/components/schemas/UrlSafetyCheckResponseFull'
            text/xml:
              schema:
                $ref: '#/components/schemas/UrlSafetyCheckResponseFull'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/UrlSafetyCheckRequestFull'
          text/json:
            schema:
              $ref: '#/components/schemas/UrlSafetyCheckRequestFull'
        description: Input URL request
        required: true
  /validate/domain/url/ssrf-threat-check:
    post:
      tags:
      - Domain
      summary: Check a URL for SSRF threats
      description: Checks if an input URL is at risk of being an SSRF (Server-side request forgery) threat or attack.
      operationId: Domain_SsrfCheck
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UrlSsrfResponseFull'
            text/json:
              schema:
                $ref: '#/components/schemas/UrlSsrfResponseFull'
            application/xml:
              schema:
                $ref: '#/components/schemas/UrlSsrfResponseFull'
            text/xml:
              schema:
                $ref: '#/components/schemas/UrlSsrfResponseFull'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/UrlSsrfRequestFull'
          text/json:
            schema:
              $ref: '#/components/schemas/UrlSsrfRequestFull'
        description: Input URL request
        required: true
  /validate/domain/url/ssrf-threat-check/batch:
    post:
      tags:
      - Domain
      summary: Check a URL for SSRF threats in batches
      description: Batch-checks if input URLs are at risk of being an SSRF (Server-side request forgery) threat or attack.
      operationId: Domain_SsrfCheckBatch
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UrlSsrfResponseBatch'
            text/json:
              schema:
                $ref: '#/components/schemas/UrlSsrfResponseBatch'
            application/xml:
              schema:
                $ref: '#/components/schemas/UrlSsrfResponseBatch'
            text/xml:
              schema:
                $ref: '#/components/schemas/UrlSsrfResponseBatch'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/UrlSsrfRequestBatch'
          text/json:
            schema:
              $ref: '#/components/schemas/UrlSsrfRequestBatch'
        description: Input URL request as a batch of multiple URLs
        required: true
  /validate/domain/url/ssrf-threat-check/html-embedded:
    post:
      tags:
      - Domain
      summary: Check a URL for HTML embedded SSRF threats
      description: Checks if an input URL HTML is at risk of containing one or more embedded SSRF (Server-side request forgery) threats or attacks.
      operationId: Domain_UrlHtmlSsrfCheck
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UrlHtmlSsrfResponseFull'
            text/json:
              schema:
                $ref: '#/components/schemas/UrlHtmlSsrfResponseFull'
            application/xml:
              schema:
                $ref: '#/components/schemas/UrlHtmlSsrfResponseFull'
            text/xml:
              schema:
                $ref: '#/components/schemas/UrlHtmlSsrfResponseFull'
      security:
      - Apikey: []
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/UrlHtmlSsrfRequestFull'
          text/json:
            schema:
              $ref: '#/components/schemas/UrlHtmlSsrfRequestFull'
        description: Input URL request
        required: true
components:
  schemas:
    UrlSsrfResponseFull:
      description: Result of checking a URL for SSRF threats
      type: object
      properties:
        CleanURL:
          description: True if the URL is clean, false if it is at risk of containing an SSRF threat or attack
          type: boolean
        ThreatLevel:
          description: Threat level of the URL; possible values are High, Medium, Low and None
          type: string
    UrlSafetyCheckResponseFull:
      description: Result of checking a URL for safety threats
      type: object
      properties:
        CleanURL:
          description: True if the URL is clean, false if it is at risk of containing a safety threat or attack
          type: boolean
        ThreatType:
          description: Threat type identified, if any; possible values are "ForcedDownload", "VirusesAndMalware", "Phishing"
          type: string
    ValidateUrlRequestSyntaxOnly:
      description: Request to determine if a URL is valid
      type: object
      properties:
        URL:
          description: URL to validate
          type: string
    WhoisResponse:
      description: Result of a WHOIS operation
      type: object
      properties:
        ValidDomain:
          description: True if the domain is valid, false if it is not
          type: boolean
        RegistrantName:
          description: Name of the domain registrant
          type: string
        RegistrantOrganization:
          description: Organization name of the domain registrant
          type: string
        RegistrantEmail:
          description: Email address of the domain registrant
          type: string
        RegistrantStreetNumber:
          description: Street number of the address of the domain registrant, if available
          type: string
        RegistrantStreet:
          description: Street name of the address of the domain registrant, if available
          type: string
        RegistrantCity:
          description: City of the domain registrant, if available
          type: string
        RegistrantStateOrProvince:
          description: State or Province of the address of the domain registrant, if available
          type: string
        RegistrantPostalCode:
          description: Postal code of the address of the domain registrant, if available
          type: string
        RegistrantCountry:
          description: Country of the address of the domain registrant, if available
          type: string
        RegistrantRawAddress:
          description: Raw address string of the domain registrant, if available
          type: string
        RegistrantTelephone:
          description: Telephone number of the address of the domain registrant
          type: string
        WhoisServer:
          description: Server used to lookup WHOIS information (may change based on lookup).
          type: string
        RawTextRecord:
          description: WHOIS raw text record
          type: string
        CreatedDt:
          format: date-time
          description: Creation date for the record
          type: string
    ValidateUrlRequestFull:
      description: Request to determine if a URL is valid
      type: object
      properties:
        URL:
          description: URL to validate
          type: string
    UrlHtmlSsrfResponseFull:
      description: Result of checking a URL for HTML-embedded SSRF threats
      type: object
      properties:
        CleanURL:
          description: True if the URL is clean, false if it is at risk of containing an SSRF threat or attack
          type: boolean
        HttpResponseCode:
          format: int32
          description: HTTP response code from the URL
          type: integer
    IsAdminPathResponse:
      description: Result of performing an Admin Path operation
      type: object
      properties:
        IsAdminPathNode:
          description: True if the input IP address is an Admin Path, and false otherwise
          type: boolean
        Successful:
          description: True if the operation was successful, false otherwise
          type: boolean
    UrlHtmlSsrfRequestFull:
      description: Request to determine if a URL contains HTML-embedded SSRF threats
      type: object
      properties:
        URL:
          description: URL to validate
          type: string
    UrlSsrfRequestBatch:
      description: Batch operation to perform SSRF threat checks on multiple URLs
      type: object
      properties:
        InputItems:
          description: Input URLs to check for SSRF threats
          type: array
          items:
            $ref: '#/components/schemas/UrlSsrfRequestFull'
    UrlSsrfRequestFull:
      description: Request to determine if a URL is an SSRF threat check
      type: object
      properties:
        URL:
          description: URL to validate
          type: string
        BlockedDomains:
          description: Top level domains that you do not want to allow access to, e.g. mydomain.com - will block all subdomains as well
          type: array
          items:
            type: string
    UrlSsrfResponseBatch:
      description: Result of performing SSRF threat checks on multiple URLs
      type: object
      properties:
        OutputItems:
          description: Results of the operation, with indexes matched to input values
          type: array
          items:
            $ref: '#/components/schemas/UrlSsrfResponseFull'
    DomainQualityResponse:
      description: Result of performing a domain quality score operation
      type: object
      properties:
        DomainQualityScore:
          format: double
          description: The quality score of the domain name; possible values are 0.0 to 10.0 with 10.0 being the highest and 0.0 being the lowest quality.
          type: number
    PhishingCheckRequest:
      description: Request to determine if a URL is a Phishing threat
      type: object
      properties:
        URL:
          description: URL to validate
          type: string
    CheckResponse:
      description: Result of a validation operation
      type: object
      properties:
        ValidDomain:
          description: True if the domain name was valid, false if it is not
          type: boolean
    ValidateUrlResponseFull:
      description: Result of validating a URL with full validation
      type: object
      properties:
        ValidURL:
          description: True if the URL has valid syntax, a valid domain, a valid endpoint, and passes virus scan checks; false otherwise
          type: boolean
        Valid_Syntax:
          description: True if the URL has valid syntax, false otherwise
          type: boolean
        Valid_Domain:
          description: True if the domain name is valid and exists, false otherwise
          type: boolean
        Valid_Endpoint:
          description: True if the endpoint is up and responsive and passes a virus scan check, false otherwise
          type: boolean
        WellFormedURL:
          description: Well-formed version of the URL
          type: string
    PhishingCheckResponse:
      description: Result of checking a URL for Phishing threats
      type: object
      properties:
        CleanURL:
          description: True if the URL is clean, false if it is at risk of containing a Phishing threat or attack
          type: boolean
        ThreatType:
          description: Threat type of the Phishing threat; possible values are VerifiedPhishingURL, UnverifiedPhishingURL, or VerifiedPhishingDomain
          type: string
    UrlSafetyCheckRequestFull:
      description: Request to determine if a URL is a safety threat check
      type: object
      properties:
        URL:
          description: URL to validate
          type: string
    ValidateUrlResponseSyntaxOnly:
      description: Result of validating a URL with syntax only
      type: object
      properties:
        ValidURL:
          description: True if the URL is valid, false otherwise
          type: boolean
        WellFormedURL:
          description: Well-formed version of the URL
          type: string
        TopLevelDomainName:
          description: The top-level domain name of the URL, e.g. mydomain.com
          type: string
  securitySchemes:
    Apikey:
      type: apiKey
      description: API Key Authentication
      name: Apikey
      in: header
x-provenance:
  method: harvested
  publisher: Cloudmersive
  source: https://api.cloudmersive.com/validate/docs/v1/swagger
  note: split by refine-openapis from the provider's own published document, verified by fetch (openapi/_original/*.fetch.json);
    stamped by stamp-openapi-provenance.py (roadmap#793)