Go API Integration
api
live
package main
import (
"fmt"
"net/http"
"strings"
"io/ioutil"
)
func main() {
var payload *strings.Reader = nil
req, _ := http.NewRequest("GET", "https://api.whoisfreaks.com/v1.0/whois?apiKey=API_KEY&whois=live&domainName=google.com", payload)
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Historical
package main
import (
"fmt"
"net/http"
"strings"
"io/ioutil"
)
func main() {
var payload *strings.Reader = nil
req, _ := http.NewRequest("GET", "https://api.whoisfreaks.com/v1.0/whois?apiKey=API_KEY&whois=historical&domainName=google.com", payload)
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Reverse
package main
import (
"fmt"
"net/http"
"strings"
"io/ioutil"
)
func main() {
var payload *strings.Reader = nil
req, _ := http.NewRequest("GET", "https://api.whoisfreaks.com/v1.0/whois?apiKey=API_KEY&whois=reverse&keyword=youtube", payload)
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Bulk Whois
package main
import (
"fmt"
"net/http"
"strings"
"io/ioutil"
)
func main() {
payload := strings.NewReader("{"domainNames": ["amazon.ch","google.com","whoisfreaks.com","nic.dev","news.si"]}")
req, _ := http.NewRequest("GET", "https://api.whoisfreaks.com/v1.0/bulkwhois?apiKey=API_KEY", payload)
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}Best WHOIS Lookup SDK: Integrate WhoisFreaks APIs using Go
The WHOIS Go Lang SDK of WhoisFreaks provides powerful WHOIS lookup capabilities, enabling developers to retrieve live and historical WHOIS data. With this feature, you can access detailed domain registration information, track ownership history, and gain insights into domain changes, making it a key tool for domain analysis and cybersecurity.
How to perform WHOIS lookup(s) in go?
Go WHOIS SDK package allows you to perform various types of WHOIS lookups, including live, historical, and reverse lookups.
To use the WhoisFreaks Go SDK for WHOIS lookups, follow these steps:
1. WHOIS Authentication Setup
To authenticate your API requests, set your API key using the SetAPIKey method provided by the SDK. This method sets the global API key to the specified value.
func SetAPIKey(key string)Parameters:
- key: A string representing the API key to be set.
Example Usage:
package main
import (
"github.com/WhoisFreaks/whoisfreaks/whois"
)
func main() {
whois.SetAPIKey("your_api_key")
// Your code here
}Replace "your_api_key" with your actual API key.
2. WHOIS Live Lookup
GetLiveResponse retrieves live WHOIS information for a specific domain using the WhoisFreaks API.
func GetLiveResponse(domain string) (*modal.DomainInfo, *modal.Error)Parameters:
- domain: The domain name for which live WHOIS information is requested (e.g., "example.com").
Returns:
- *modal.DomainInfo: A pointer to a DomainInfo struct containing live domain information.
- *modal.Error: A pointer to an Error struct if there is an API error, or nil if the request is successful.
Example Usage:
package main
import (
"fmt"
"log"
"github.com/WhoisFreaks/whoisfreaks/whois"
)
func main() {
whois.SetAPIKey("your_api_key")
domain := "example.com"
result, err := whois.LiveLookup(domain)
if err != nil {
log.Fatal(err)
}
fmt.Println(result)
}Replace "example.com" with the domain you wish to query.
3. WHOIS Bulk Live Lookup
GetBulkLiveResponse retrieves live WHOIS information for multiple domains in bulk using the WhoisFreaks API.
func GetBulkLiveResponse(domains []string) (*modal.BulkDomainInfo, *modal.Error)Parameters:
- domains: A slice of strings containing the domain names for which live WHOIS information is requested.
Returns:
- *modal.BulkDomainInfo: A pointer to a BulkDomainInfo struct containing live domain information for the bulk request.
- *modal.Error: A pointer to an Error struct if there is an API error, or nil if the request is successful.
Example Usage:
package main
import (
"fmt"
"log"
"github.com/WhoisFreaks/whoisfreaks/whois"
)
func main() {
whois.SetAPIKey("your_api_key")
domains := []string{"example1.com", "example2.com", "example3.com"}
results, err := whois.BulkLiveLookup(domains)
if err != nil {
log.Fatal(err)
}
for _, result := range results {
fmt.Println(result)
}
}Replace the domain names in the domains slice with the domains you wish to query.
4. WHOIS Historical Lookup
GetHistoricalResponse retrieves historical WHOIS information using the WhoisFreaks API.
func GetHistoricalResponse(domain string) (*modal.HistoricalDomainInfo, *modal.Error)Parameters:
- domain: The domain name for which historical WHOIS information is requested (e.g., "example.com").
Returns:
- *modal.HistoricalDomainInfo: A pointer to a HistoricalDomainInfo struct containing historical domain information.
- *modal.Error: A pointer to an Error struct if there is an API error, or nil if the request is successful.
Example Usage:
package main
import (
"fmt"
"log"
"github.com/WhoisFreaks/whoisfreaks/whois"
)
func main() {
whois.SetAPIKey("your_api_key")
domain := "example.com"
result, err := whois.HistoricalLookup(domain)
if err != nil {
log.Fatal(err)
}
fmt.Println(result)
}Replace "example.com" with the domain you wish to query.
5. WHOIS Reverse Lookup
GetReverseResponse performs a reverse WHOIS lookup using the WhoisFreaks API.
func GetReverseResponse(keyword, email, company, owner, page string) (*modal.ReverseDomainInfo, *modal.Error)Parameters:
- keyword: The keyword to search for in domain records.
- email: The email address to search for in domain records.
- company: The company name to search for in domain records.
- owner: The owner name to search for in domain records.
- page: The optional page number for paginated results. Leave empty for the first page.
Returns:
- *modal.ReverseDomainInfo: A pointer to a ReverseDomainInfo struct containing reverse WHOIS information.
- *modal.Error: A pointer to an Error struct if there is an API error, or nil if the request is successful.
Example Usage:
package main
import (
"fmt"
"log"
"github.com/WhoisFreaks/whoisfreaks/whois"
)
func main() {
whois.SetAPIKey("your_api_key")
keyword := "whoisfreaks"
email := "[email protected]"
owner := "elon"
company := "google"
page := "2"
result, err := whois.GetReverseResponse(keyword, email, company, owner, page)
if err != nil {
log.Fatal(err)
}
fmt.Println(result)
}Replace keyword, email, owner, company, and page with the desired keyword, email address, owner name, company name, and page number, respectively.
6. WHOIS Reverse Mini Lookup
GetReverseMiniResponse performs a reverse WHOIS lookup in mini mode using the WhoisFreaks API.
func GetReverseMiniResponse(keyword, email, company, owner, page string) (*modal.ReverseMiniDomainInfo, *modal.Error)Parameters:
- keyword: The keyword to search for in domain records.
- email: The email address to search for in domain records.
- company: The company name to search for in domain records.
- owner: The owner name to search for in domain records.
- page: The optional page number for paginated results. Leave empty for the first page.
Returns:
- *modal.ReverseMiniDomainInfo: A pointer to a ReverseMiniDomainInfo struct containing reverse WHOIS information in mini mode.
- *modal.Error: A pointer to an Error struct if there is an API error, or nil if the request is successful.
Example Usage:
package main
import (
"fmt"
"log"
"github.com/WhoisFreaks/whoisfreaks/whois"
)
func main() {
whois.SetAPIKey("your_api_key")
keyword := "whoisfreaks"
email := "[email protected]"
owner := "elon"
company := "google"
page := "2"
result, err := whois.GetReverseMiniResponse(keyword, email, company, owner, page)
if err != nil {
log.Fatal(err)
}
fmt.Println(result)
}Replace keyword, email, owner, company, and page with the desired keyword, email address, owner name, company name, and page number, respectively.
Other SDK Lookups
WHOIS lookups
Offers live, reverse, historical, IP, ASN, and bulk domain WHOIS lookups.
DNS Lookups
Provides live, reverse, historical, and bulk DNS lookup services.
Domain Availability
Checks domain availability across TLDs and suggests alternatives.
SSL Lookups
Performs SSL lookup and shows certificate chain from start to present.
WhoisFreaks GoLang SDK | CLI Tool
Leverage this Go Lang-based SDK and CLI tool to interact with the WhoisFreaks API seamlessly.
pkg.go.dev