@pipedream/whoisfreaks 0.1.0 → 0.1.2

package/actions/bulk-dns-domain-lookup/bulk-dns-domain-lookup.mjs

@@ -0,0 +1,81 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+import { ConfigurationError } from "@pipedream/platform";
+import { parseObject } from "../../common/utils.mjs";
+
+export default {
+  key: "whoisfreaks-bulk-dns-domain-lookup",
+  name: "Bulk DNS Domain Lookup",
+  description: "Retrieve DNS records (A, AAAA, MX, NS, CNAME, TXT, PTR, SPF, DKIM, DMARC, SRV, SOA) for up to 100 domains or IP addresses in a single request. Use this action for bulk DNS auditing, infrastructure mapping, or automated monitoring. Accepts domain names and/or IP addresses; returns JSON or XML output. [See the documentation](https://whoisfreaks.com/documentation/dns-checker-api#bulk-domain-lookup)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    whoisfreaks,
+    domainNames: {
+      propDefinition: [
+        whoisfreaks,
+        "domainNames",
+      ],
+      optional: true,
+    },
+    ipAddresses: {
+      propDefinition: [
+        whoisfreaks,
+        "ipAddresses",
+      ],
+      optional: true,
+    },
+    format: {
+      propDefinition: [
+        whoisfreaks,
+        "format",
+      ],
+    },
+  },
+
+  async run({ $ }) {
+    const domainNames = this.domainNames
+      ? parseObject(this.domainNames)
+      : [];
+
+    const ipAddresses = this.ipAddresses
+      ? parseObject(this.ipAddresses)
+      : [];
+
+    if (!domainNames.length && !ipAddresses.length) {
+      throw new ConfigurationError(
+        "Please provide at least one domain name or IP address.",
+      );
+    }
+
+    const response = await this.whoisfreaks.lookupBulkDnsDomain({
+      $,
+      params: {
+        format: this.format,
+        type: "all",
+      },
+      body: {
+        ...(domainNames.length && {
+          domainNames,
+        }),
+        ...(ipAddresses.length && {
+          ipAddresses,
+        }),
+      },
+    });
+
+    $.export(
+      "$summary",
+      `Successfully fetched bulk DNS data for ${
+        domainNames.length + ipAddresses.length
+      } input(s)`,
+    );
+
+    return response;
+  },
+};

package/actions/bulk-ip-geolocation-lookup/bulk-ip-geolocation-lookup.mjs

@@ -0,0 +1,46 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+import { parseObject } from "../../common/utils.mjs";
+
+export default {
+  key: "whoisfreaks-bulk-ip-geolocation-lookup",
+  name: "Bulk IP Geolocation Lookup",
+  description: "Retrieve geolocation details (country, city, ASN, ISP, coordinates) for up to 100 IP addresses in a single request. Accepts comma-separated IPv4 or IPv6 addresses and returns JSON or XML output. Use this action for bulk network analysis, fraud detection, or audience geo-enrichment. [See the documentation](https://whoisfreaks.com/documentation/ip-geolocation-api#bulk-geo-lookup)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    whoisfreaks,
+    ipAddresses: {
+      propDefinition: [
+        whoisfreaks,
+        "ipAddresses",
+      ],
+      optional: false,
+    },
+    format: {
+      propDefinition: [
+        whoisfreaks,
+        "format",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const ipAddresses = parseObject(this.ipAddresses);
+    const response = await this.whoisfreaks.lookupBulkIpGeolocation({
+      $,
+      params: {
+        format: this.format,
+      },
+      body: {
+        ips: ipAddresses,
+      },
+    });
+    $.export("$summary", `Successfully fetched bulk IP geolocation data for ${ipAddresses.length} IP(s)`);
+    return response;
+  },
+};

package/actions/bulk-ip-reputation-lookup/bulk-ip-reputation-lookup.mjs

@@ -0,0 +1,46 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+import { parseObject } from "../../common/utils.mjs";
+
+export default {
+  key: "whoisfreaks-bulk-ip-reputation-lookup",
+  name: "Bulk IP Reputation Lookup",
+  description: "Score up to 100 IPv4 or IPv6 addresses against real-time threat data in a single request. Returns composite threat score, VPN/proxy/Tor/bot classification, blacklist status, and ASN/ISP details for each IP. Accepts comma-separated IP addresses; returns JSON or XML output. [See the documentation](https://whoisfreaks.com/documentation/ip-security-api#bulk-security-lookup)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    whoisfreaks,
+    ipAddresses: {
+      propDefinition: [
+        whoisfreaks,
+        "ipAddresses",
+      ],
+      optional: false,
+    },
+    format: {
+      propDefinition: [
+        whoisfreaks,
+        "format",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const ipAddresses = parseObject(this.ipAddresses);
+    const response = await this.whoisfreaks.lookupBulkIpReputation({
+      $,
+      params: {
+        format: this.format,
+      },
+      body: {
+        ips: ipAddresses,
+      },
+    });
+    $.export("$summary", `Successfully fetched bulk IP reputation data for ${ipAddresses.length} IP(s)`);
+    return response;
+  },
+};

package/actions/bulk-whois-lookup/bulk-whois-lookup.mjs

@@ -0,0 +1,45 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+import { parseObject } from "../../common/utils.mjs";
+
+export default {
+  key: "whoisfreaks-bulk-whois-lookup",
+  name: "Bulk Whois Lookup",
+  description: "Retrieve WHOIS registration data (registrant, registrar, name servers, email, phone, address, ASN, history) for up to 100 domains in a single request. Accepts comma-separated domain names across 1000+ TLDs; returns JSON or XML output. Use this action for bulk domain research, lead enrichment, or portfolio audits. [See the documentation](https://whoisfreaks.com/documentation/bulk-whois-api)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    whoisfreaks,
+    domainNames: {
+      propDefinition: [
+        whoisfreaks,
+        "domainNames",
+      ],
+    },
+    format: {
+      propDefinition: [
+        whoisfreaks,
+        "format",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const domainNames = parseObject(this.domainNames);
+    const response = await this.whoisfreaks.lookupBulkWhois({
+      $,
+      params: {
+        format: this.format,
+      },
+      body: {
+        domainNames,
+      },
+    });
+    $.export("$summary", `Successfully fetched bulk WHOIS data for ${domainNames.length} domain(s)`);
+    return response;
+  },
+};

package/actions/domain-availability-lookup/domain-availability-lookup.mjs

@@ -0,0 +1,43 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+
+export default {
+  key: "whoisfreaks-domain-availability-lookup",
+  name: "Domain Availability Lookup",
+  description:
+    "Check if a domain name is available for registration. For example you can check whoisfreaks.com. This action supports responses in both JSON and XML format. Always use sug=false to get the response. [See the documentation](https://whoisfreaks.com/documentation/domain-availability-api#lookup)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    whoisfreaks,
+    domainName: {
+      propDefinition: [
+        whoisfreaks,
+        "domainName",
+      ],
+    },
+    format: {
+      propDefinition: [
+        whoisfreaks,
+        "format",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.whoisfreaks.lookupDomainAvailability({
+      $,
+      params: {
+        domain: this.domainName,
+        format: this.format,
+        sug: false,
+      },
+    });
+    $.export("$summary", `Successfully performed domain availability lookup for ${this.domainName}`);
+    return response;
+  },
+};

package/actions/domain-lookup/domain-lookup.mjs

@@ -3,8 +3,13 @@ import whoisfreaks from "../../whoisfreaks.app.mjs";
 export default {
   key: "whoisfreaks-domain-lookup",
   name: "Domain Lookup",
-  description: "Retrieve details about a domain name. [See the documentation](https://whoisfreaks.com/products/whois-api#live_lookup)",
-  version: "0.0.1",
+  description: "Retrieve details about a domain name. [See the documentation](https://whoisfreaks.com/documentation/whois-api)",
+  version: "0.0.3",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
   type: "action",
   props: {
     whoisfreaks,

package/actions/domain-reputation-lookup/domain-reputation-lookup.mjs

@@ -0,0 +1,34 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+
+export default {
+  key: "whoisfreaks-domain-reputation-lookup",
+  name: "Domain Reputation Lookup",
+  description: "Check the reputation and security status of a domain — including whether it is associated with malware, phishing campaigns, or other malicious activity. Use this action for threat intelligence workflows, email security checks, or domain risk scoring. Returns JSON output. [See the documentation](https://whoisfreaks.com/documentation/domain-reputation-api)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    whoisfreaks,
+    domainName: {
+      propDefinition: [
+        whoisfreaks,
+        "domainName",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.whoisfreaks.lookupDomainReputation({
+      $,
+      params: {
+        domainName: this.domainName,
+      },
+    });
+    $.export("$summary", `Successfully fetched domain reputation data for ${this.domainName}`);
+    return response;
+  },
+};

package/actions/ip-geolocation-lookup/ip-geolocation-lookup.mjs

@@ -0,0 +1,35 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+
+export default {
+  key: "whoisfreaks-ip-geolocation-lookup",
+  name: "IP Geolocation Lookup",
+  description:
+    "Retrieve geolocation details (country, city, region, ASN, ISP, coordinates) for a single IP address. Supports both IPv4 and IPv6 addresses. Use this action to enrich events with location data, perform fraud detection, or geo-target users. [See the documentation](https://whoisfreaks.com/documentation/ip-geolocation-api#geo-lookup)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    whoisfreaks,
+    ip: {
+      propDefinition: [
+        whoisfreaks,
+        "ip",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.whoisfreaks.lookupIpGeolocation({
+      $,
+      params: {
+        ip: this.ip,
+      },
+    });
+    $.export("$summary", `Successfully fetched geolocation data for IP ${this.ip}`);
+    return response;
+  },
+};

package/actions/ip-lookup/ip-lookup.mjs

@@ -3,15 +3,21 @@ import whoisfreaks from "../../whoisfreaks.app.mjs";
 export default {
   key: "whoisfreaks-ip-lookup",
   name: "IP Lookup",
-  description: "Retrieve information about an IP address. [See the documentation](https://whoisfreaks.com/products/whois-api#ip_lookup)",
-  version: "0.0.1",
+  description: "Retrieve information about an IP address. [See the documentation](https://whoisfreaks.com/documentation/ip-whois-api)",
+  version: "0.0.3",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
   type: "action",
   props: {
     whoisfreaks,
     ip: {
-      type: "string",
-      label: "IP",
-      description: "IPv4 or IPv6 address for the requested whois",
+      propDefinition: [
+        whoisfreaks,
+        "ip",
+      ],
     },
     format: {
       propDefinition: [

package/actions/ip-reputation-lookup/ip-reputation-lookup.mjs

@@ -0,0 +1,35 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+
+export default {
+  key: "whoisfreaks-ip-reputation-lookup",
+  name: "IP Reputation Lookup",
+  description: "Score a single IPv4 or IPv6 address against real-time threat data. Returns a composite threat score (0-100), VPN/proxy/Tor/bot classification, provider names with confidence scores, district-level geolocation, and ASN/ISP details. Use this action for threat intelligence, access control, or fraud prevention workflows. Accepts JSON or XML output. [See the documentation](https://whoisfreaks.com/documentation/ip-security-api#security-lookup)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    whoisfreaks,
+    ipAddress: {
+      propDefinition: [
+        whoisfreaks,
+        "ip",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.whoisfreaks.lookupIpReputation({
+      $,
+      params: {
+        ip: this.ipAddress,
+      },
+    });
+    $.export("$summary", `Successfully fetched IP reputation data for ${this.ipAddress}`);
+    return response;
+  },
+};
+

package/actions/reverse-lookup/reverse-lookup.mjs

@@ -4,21 +4,29 @@ import { ConfigurationError } from "@pipedream/platform";
 export default {
   key: "whoisfreaks-reverse-lookup",
   name: "Reverse Lookup",
-  description: "Retrieve details about a domain by keyword, email, registrant name or company. [See the documentation](https://whoisfreaks.com/products/whois-api#reverse_lookup)",
-  version: "0.0.1",
+  description:
+    "Retrieve details about a domain by keyword, email, registrant name or company. Must enter one and only one of keyword, email, owner, or company. [See the documentation](https://whoisfreaks.com/documentation/whois-api#reverse-lookup)",
+  version: "0.0.3",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
   type: "action",
   props: {
     whoisfreaks,
     keyword: {
       type: "string",
       label: "Keyword",
-      description: "Keyword search utilizes case-insensitive Pattern Matching search technique to search in our historical database. For example, `whoisfreaks` matches with any keyword that have the searched pattern like `mywhoisfreaks` and `whoisfreakscom`.",
+      description:
+        "Keyword search utilizes case-insensitive Pattern Matching search technique to search in our historical database. For example, `whoisfreaks` matches with any keyword that have the searched pattern like `mywhoisfreaks` and `whoisfreakscom`.",
       optional: true,
     },
     email: {
       type: "string",
       label: "Email",
-      description: "Email search uses case-insensitive exact matching technique to search in our historical database. For example, `support@whoisfreaks.com` matches only with `support@whoisfreaks.com`.",
+      description:
+        "Email search uses case-insensitive exact matching technique to search in our historical database. For example, `support@whoisfreaks.com` matches only with `support@whoisfreaks.com`.",
       optional: true,
     },
     owner: {
@@ -30,7 +38,8 @@ export default {
     company: {
       type: "string",
       label: "Company",
-      description: "Registrant name or Company search use full-text search technique to search in our historical database. For example, `whoisfreaks` matched with `whoisfreaks`, `whoisfreak`, `whois`, `mywhoisfreaks` and `whoisfreakscom`.",
+      description:
+        "Registrant name or Company search use full-text search technique to search in our historical database. For example, `whoisfreaks` matched with `whoisfreaks`, `whoisfreak`, `whois`, `mywhoisfreaks` and `whoisfreakscom`.",
       optional: true,
     },
     format: {
@@ -42,31 +51,46 @@ export default {
     page: {
       type: "integer",
       label: "Page",
-      description: "For getting next or desired page of whois info. Default: `1`",
+      description:
+        "For getting next or desired page of whois info. Default: `1`",
       default: 1,
       optional: true,
     },
   },
   async run({ $ }) {
-    if ([
-      this.keyword,
-      this.email,
-      this.owner,
-      this.company,
-    ].filter((v) => v !== undefined).length !== 1) {
-      throw new ConfigurationError("Must enter one and only one of `keyword`, `email`, `owner`, or `company`");
+    const normalize = (v) =>
+      typeof v === "string" && v.trim() === ""
+        ? undefined
+        : v;
+
+    const keyword = normalize(this.keyword);
+    const email = normalize(this.email);
+    const owner = normalize(this.owner);
+    const company = normalize(this.company);
+
+    const activeCount = [
+      keyword,
+      email,
+      owner,
+      company,
+    ].filter((v) => v !== undefined && v !== null).length;
+
+    if (activeCount !== 1) {
+      throw new ConfigurationError(
+        "Must enter one and only one of keyword, email, owner, or company",
+      );
     }
 
     const response = await this.whoisfreaks.domainLookup({
       $,
       params: {
-        keyword: this.keyword,
-        email: this.email,
-        owner: this.owner,
-        company: this.company,
+        keyword,
+        email,
+        owner,
+        company,
         whois: "reverse",
         format: this.format,
-        page: this.page,
+        page: this.page || 1,
       },
     });
 

package/actions/ssl-lookup/ssl-lookup.mjs

@@ -0,0 +1,47 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+
+export default {
+  key: "whoisfreaks-ssl-lookup",
+  name: "SSL Lookup",
+  description:
+    "Retrieve details about a domain's SSL certificate (e.g. google.com). Note that this action accepts JSON or XML format values, always requests the full certificate chain (chain=true), and suppresses the raw OpenSSL response (sslRaw=false) for cleaner outputs. [See the documentation](https://whoisfreaks.com/documentation/ssl-certificate-api)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    whoisfreaks,
+    domainName: {
+      propDefinition: [
+        whoisfreaks,
+        "domainName",
+      ],
+    },
+    format: {
+      propDefinition: [
+        whoisfreaks,
+        "format",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.whoisfreaks.lookupSsl({
+      $,
+      params: {
+        domainName: this.domainName,
+        format: this.format,
+        chain: true,
+        sslRaw: false,
+      },
+    });
+    $.export(
+      "$summary",
+      `Successfully performed SSL lookup for ${this.domainName}`,
+    );
+    return response;
+  },
+};

package/actions/sub-domain-lookup/sub-domain-lookup.mjs

@@ -0,0 +1,52 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+
+export default {
+  key: "whoisfreaks-sub-domain-lookup",
+  name: "Subdomain Lookup",
+  description:
+    "Discover subdomains for a given domain using passive DNS data from 6.3B+ indexed hostnames. Returns active, inactive, and historical subdomain records. Use this action for attack surface mapping, security audits, or competitor research. Returns JSON or XML output. [See the documentation](https://whoisfreaks.com/documentation/subdomains-api)",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    readOnlyHint: true,
+    openWorldHint: true,
+  },
+  type: "action",
+  ai: "optimized",
+  props: {
+    whoisfreaks,
+    domainName: {
+      propDefinition: [
+        whoisfreaks,
+        "domainName",
+      ],
+    },
+    format: {
+      propDefinition: [
+        whoisfreaks,
+        "format",
+      ],
+    },
+    page: {
+      type: "integer",
+      label: "Page",
+      description:
+        "For getting next or desired page of whois info. Default: `1`",
+      default: 1,
+      min: 1,
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const response = await this.whoisfreaks.lookupSubDomain({
+      $,
+      params: {
+        domain: this.domainName,
+        format: this.format,
+        page: this.page || 1,
+      },
+    });
+    $.export("$summary", `Successfully fetched subdomain data for ${this.domainName}`);
+    return response;
+  },
+};

package/common/utils.mjs

@@ -0,0 +1,28 @@
+const splitCommaSeparated = (value) =>
+  value.split(",").map((v) => v.trim())
+    .filter(Boolean);
+
+export const parseObject = (obj) => {
+  if (!obj) return undefined;
+
+  if (Array.isArray(obj)) {
+    return obj.flatMap((item) => {
+      if (typeof item === "string") {
+        try {
+          return JSON.parse(item);
+        } catch (e) {
+          return splitCommaSeparated(item);
+        }
+      }
+      return item;
+    });
+  }
+  if (typeof obj === "string") {
+    try {
+      return JSON.parse(obj);
+    } catch (e) {
+      return splitCommaSeparated(obj);
+    }
+  }
+  return obj;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/whoisfreaks",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Pipedream WhoisFreaks Components",
   "main": "whoisfreaks.app.mjs",
   "keywords": [
@@ -13,6 +13,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@pipedream/platform": "^3.0.3"
+    "@pipedream/platform": "^3.1.1"
   }
 }

package/whoisfreaks.app.mjs

@@ -7,31 +7,60 @@ export default {
     domainName: {
       type: "string",
       label: "Domain Name",
-      description: "The domain name to lookup",
+      description: "The domain name to lookup (e.g. `example.com`)",
+    },
+    domainNames: {
+      type: "string[]",
+      label: "Domain Names",
+      description: "Domain names to look up (e.g. `example.com`, `google.com`). Add one or more values. Supports up to 100 domains per request.",
+    },
+    ipAddresses: {
+      type: "string[]",
+      label: "IP Addresses",
+      description: "IP addresses to look up. Must be valid IPv4 or IPv6 addresses (e.g. `8.8.8.8`, `1.1.1.1`). Add one or more values. Supports up to 100 IPs per request.",
+      optional: true,
+    },
+    ip: {
+      type: "string",
+      label: "IP Address",
+      description: "The IP address to look up. Must be a valid IPv4 (e.g. `8.8.8.8`) or IPv6 (e.g. `2001:4860:4860::8888`) address.",
     },
     format: {
       type: "string",
       label: "Format",
-      description: "Two formats are available JSON, XML. If you don't specify the 'format' parameter, the default format will be JSON.",
+      description:
+        "Two formats are available JSON, XML. If you don't specify the 'format' parameter, the default format will be JSON.",
       options: [
         "JSON",
         "XML",
       ],
+      default: "JSON",
       optional: true,
     },
   },
   methods: {
     _baseUrl() {
-      return "https://api.whoisfreaks.com/v1.0";
+      return "https://api.whoisfreaks.com";
     },
     _makeRequest({
-      $ = this,
-      path,
-      params,
-      ...opts
+      $ = this, path, params, ...opts
+    }) {
+      return axios($, {
+        url: `${this._baseUrl()}${path}`,
+        params: {
+          ...params,
+          apiKey: this.$auth.api_key,
+        },
+        ...opts,
+      });
+    },
+    _makePostRequest({
+      $ = this, path, params, body, ...opts
     }) {
       return axios($, {
         url: `${this._baseUrl()}${path}`,
+        method: "POST",
+        data: body,
         params: {
           ...params,
           apiKey: this.$auth.api_key,
@@ -41,13 +70,73 @@ export default {
     },
     domainLookup(opts = {}) {
       return this._makeRequest({
-        path: "/whois",
+        path: "/v1.0/whois",
         ...opts,
       });
     },
     ipLookup(opts = {}) {
       return this._makeRequest({
-        path: "/ip-whois",
+        path: "/v1.0/ip-whois",
+        ...opts,
+      });
+    },
+    lookupDomainAvailability(opts = {}) {
+      return this._makeRequest({
+        path: "/v1.0/domain/availability",
+        ...opts,
+      });
+    },
+    lookupSsl(opts = {}) {
+      return this._makeRequest({
+        path: "/v1.0/ssl/live",
+        ...opts,
+      });
+    },
+    lookupIpGeolocation(opts = {}) {
+      return this._makeRequest({
+        path: "/v1.0/geolocation",
+        ...opts,
+      });
+    },
+    lookupSubDomain(opts = {}) {
+      return this._makeRequest({
+        path: "/v1.0/subdomains",
+        ...opts,
+      });
+    },
+    lookupDomainReputation(opts = {}) {
+      return this._makeRequest({
+        path: "/v1/domain/security",
+        ...opts,
+      });
+    },
+    lookupIpReputation(opts = {}) {
+      return this._makeRequest({
+        path: "/v1.0/security",
+        ...opts,
+      });
+    },
+    lookupBulkWhois(opts = {}) {
+      return this._makePostRequest({
+        path: "/v2.0/bulkwhois/live",
+        ...opts,
+      });
+    },
+    lookupBulkDnsDomain(opts = {}) {
+      return this._makePostRequest({
+        path: "/v2.0/dns/bulk/live",
+        ...opts,
+      });
+    },
+    lookupBulkIpGeolocation(opts = {}) {
+      return this._makePostRequest({
+        path: "/v1.0/geolocation",
+        ...opts,
+      });
+    },
+    lookupBulkIpReputation(opts = {}) {
+      return this._makePostRequest({
+        path: "/v1.0/security",
         ...opts,
       });
     },