@pipedream/whoisfreaks 0.0.1 → 0.1.1

package/README.md

@@ -0,0 +1,11 @@
+# Overview
+
+The WhoisFreaks API offers a way to dig into the riches of domain registration data. With this API, you can retrieve extensive WHOIS records, including registrar details, domain status, creation and expiration dates, and registrant information, among other data. When integrated with Pipedream's serverless platform, you unlock the potential to automate domain research, track domain registrations, monitor changes, and connect insights with other apps for a multitude of purposes.
+
+# Example Workflows
+
+- **Domain Registration Monitoring**: Build a workflow on Pipedream that tracks domain registrations for specific keywords. When a new domain containing the keyword is registered, use WhoisFreaks to fetch WHOIS data and send alerts via Slack or email to the interested parties.
+
+- **Trademark Protection**: Set up a Pipedream workflow to monitor the registration of domains similar to your trademarks. WhoisFreaks can be used to identify potential trademark infringements, and you can connect to a CRM like Salesforce to initiate a follow-up action or legal response.
+
+- **Competitive Intelligence Gathering**: Create a Pipedream workflow to perform regular searches for domains registered by your competitors. Utilize WhoisFreaks API to extract relevant data and compile it into a report, which can be periodically sent to Google Sheets for analysis and shared with your team.

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

@@ -0,0 +1,68 @@
+// x-pd-ai: optimized
+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.1",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  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,40 @@
+// x-pd-ai: optimized
+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.1",
+    annotations: {
+        destructiveHint: false,
+        openWorldHint: true,
+        readOnlyHint: true,
+    },
+    type: "action",
+    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,40 @@
+// x-pd-ai: optimized
+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.1",
+    annotations: {
+        destructiveHint: false,
+        openWorldHint: true,
+        readOnlyHint: true,
+    },
+    type: "action",
+    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,39 @@
+// x-pd-ai: optimized
+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.1",
+    annotations: {
+        destructiveHint: false,
+        openWorldHint: true,
+        readOnlyHint: true,
+    },
+    type: "action",
+    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,37 @@
+// x-pd-ai: optimized
+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.1",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  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

@@ -0,0 +1,50 @@
+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/documentation/whois-api)",
+  version: "0.0.3",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  props: {
+    whoisfreaks,
+    domainName: {
+      propDefinition: [
+        whoisfreaks,
+        "domainName",
+      ],
+    },
+    lookupType: {
+      type: "string",
+      label: "Lookup Type",
+      description: "Whether to perform a `live` or `historical` lookup",
+      options: [
+        "live",
+        "historical",
+      ],
+    },
+    format: {
+      propDefinition: [
+        whoisfreaks,
+        "format",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.whoisfreaks.domainLookup({
+      $,
+      params: {
+        domainName: this.domainName,
+        whois: this.lookupType,
+        format: this.format,
+      },
+    });
+    $.export("$summary", `Successfully performed lookup for domain ${this.domainName}`);
+    return response;
+  },
+};

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

@@ -0,0 +1,31 @@
+// x-pd-ai: optimized
+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.1",
+    annotations: {
+        destructiveHint: false,
+        openWorldHint: true,
+        readOnlyHint: true,
+    },
+    type: "action",
+    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,32 @@
+// x-pd-ai: optimized
+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.1",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  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

@@ -0,0 +1,37 @@
+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/documentation/ip-whois-api)",
+  version: "0.0.3",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  props: {
+    whoisfreaks,
+    ip: {
+      propDefinition: [whoisfreaks, "ip"],
+    },
+    format: {
+      propDefinition: [
+        whoisfreaks,
+        "format",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.whoisfreaks.ipLookup({
+      $,
+      params: {
+        ip: this.ip,
+        format: this.format,
+      },
+    });
+    $.export("$summary", `Successfully performed lookup for IP ${this.ip}`);
+    return response;
+  },
+};

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

@@ -0,0 +1,32 @@
+// x-pd-ai: optimized
+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.1",
+    annotations: {
+        destructiveHint: false,
+        openWorldHint: true,
+        readOnlyHint: true,
+    },
+    type: "action",
+    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

@@ -0,0 +1,94 @@
+import whoisfreaks from "../../whoisfreaks.app.mjs";
+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. 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`.",
+      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`.",
+      optional: true,
+    },
+    owner: {
+      type: "string",
+      label: "Owner",
+      description: "The owner name for requested whois",
+      optional: true,
+    },
+    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`.",
+      optional: true,
+    },
+    format: {
+      propDefinition: [whoisfreaks, "format"],
+    },
+    page: {
+      type: "integer",
+      label: "Page",
+      description:
+        "For getting next or desired page of whois info. Default: `1`",
+      default: 1,
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    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,
+        email,
+        owner,
+        company,
+        whois: "reverse",
+        format: this.format,
+        page: this.page || 1,
+      },
+    });
+
+    $.export("$summary", "Successfully performed reverse lookup");
+    return response;
+  },
+};

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

@@ -0,0 +1,41 @@
+// x-pd-ai: optimized
+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.1",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  type: "action",
+  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,46 @@
+// x-pd-ai: optimized
+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.1",
+  annotations: {
+    destructiveHint: false,
+    readOnlyHint: true,
+    openWorldHint: true,
+  },
+  type: "action",
+  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,27 @@
+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.0.1",
+  "version": "0.1.1",
   "description": "Pipedream WhoisFreaks Components",
   "main": "whoisfreaks.app.mjs",
   "keywords": [
@@ -11,5 +11,8 @@
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^3.1.1"
   }
 }

package/whoisfreaks.app.mjs

@@ -1,11 +1,137 @@
+import { axios } from "@pipedream/platform";
+
 export default {
   type: "app",
   app: "whoisfreaks",
-  propDefinitions: {},
+  propDefinitions: {
+    domainName: {
+      type: "string",
+      label: "Domain Name",
+      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.",
+      options: ["JSON", "XML"],
+      default: "JSON",
+      optional: true,
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    _baseUrl() {
+      return "https://api.whoisfreaks.com";
+    },
+    _makeRequest({ $ = 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,
+        },
+        ...opts,
+      });
+    },
+    domainLookup(opts = {}) {
+      return this._makeRequest({
+        path: "/v1.0/whois",
+        ...opts,
+      });
+    },
+    ipLookup(opts = {}) {
+      return this._makeRequest({
+        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
+      });
     },
   },
-};
+};