Indiwtf API

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

const (
	apiToken = "YOUR_API_TOKEN"
	baseURL  = "https://indiwtf.com/api"
)

type CheckResponse struct {
	Domain string `json:"domain"`
	Status string `json:"status"`
	IP     string `json:"ip"`
}

type ErrorResponse struct {
	Error string `json:"error"`
}

func checkDomain(domain string) (*CheckResponse, error) {
	url := fmt.Sprintf("%s/check?domain=%s&token=%s", baseURL, domain, apiToken)
	
	resp, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	
	if resp.StatusCode != http.StatusOK {
		var errResp ErrorResponse
		if err := json.Unmarshal(body, &errResp); err != nil {
			return nil, fmt.Errorf("API error: %d", resp.StatusCode)
		}
		return nil, fmt.Errorf("API error: %s", errResp.Error)
	}
	
	var checkResp CheckResponse
	if err := json.Unmarshal(body, &checkResp); err != nil {
		return nil, err
	}
	
	return &checkResp, nil
}

func main() {
	domain := "example.com"
	result, err := checkDomain(domain)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}
	
	if result.Status == "blocked" {
		fmt.Printf("%s is blocked in Indonesia\n", result.Domain)
	} else {
		fmt.Printf("%s is accessible in Indonesia\n", result.Domain)
	}
}

import requests

API_TOKEN = "YOUR_API_TOKEN"
BASE_URL = "https://indiwtf.com/api"

def check_domain(domain):
    url = f"{BASE_URL}/check?domain={domain}&token={API_TOKEN}"
    
    try:
        response = requests.get(url)
        response.raise_for_status()  # Raise exception for bad status codes
        
        data = response.json()
        return data
    except requests.exceptions.HTTPError as http_err:
        try:
            error_data = response.json()
            error_message = error_data.get("error", f"API error: {response.status_code}")
        except ValueError:
            error_message = f"API error: {response.status_code}"
        
        raise Exception(error_message) from http_err
    except requests.exceptions.RequestException as req_err:
        raise Exception(f"Request error: {req_err}") from req_err

# Usage
if __name__ == "__main__":
    try:
        domain = "example.com"
        result = check_domain(domain)
        
        if result["status"] == "blocked":
            print(f"{result['domain']} is blocked in Indonesia")
        else:
            print(f"{result['domain']} is accessible in Indonesia")
    except Exception as e:
        print(f"Error: {e}")

<?php

function checkDomain($domain) {
    $apiToken = 'YOUR_API_TOKEN';
    $baseUrl = 'https://indiwtf.com/api';
    
    $url = sprintf('%s/check?domain=%s&token=%s', $baseUrl, urlencode($domain), urlencode($apiToken));
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    
    if (curl_errno($ch)) {
        $error = curl_error($ch);
        curl_close($ch);
        throw new Exception("cURL Error: " . $error);
    }
    
    curl_close($ch);
    
    $data = json_decode($response, true);
    
    if ($httpCode !== 200) {
        $errorMessage = isset($data['error']) ? $data['error'] : "API error: " . $httpCode;
        throw new Exception($errorMessage);
    }
    
    return $data;
}

// Usage
try {
    $domain = "example.com";
    $result = checkDomain($domain);
    
    if ($result['status'] === 'blocked') {
        echo $result['domain'] . " is blocked in Indonesia\n";
    } else {
        echo $result['domain'] . " is accessible in Indonesia\n";
    }
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}
?>

require 'net/http'
require 'uri'
require 'json'

API_TOKEN = 'YOUR_API_TOKEN'
BASE_URL = 'https://indiwtf.com/api'

def check_domain(domain)
  uri = URI("#{BASE_URL}/check")
  params = { domain: domain, token: API_TOKEN }
  uri.query = URI.encode_www_form(params)
  
  begin
    response = Net::HTTP.get_response(uri)
    data = JSON.parse(response.body)
    
    if response.code.to_i != 200
      error_message = data['error'] || "API error: #{response.code}"
      raise StandardError.new(error_message)
    end
    
    return data
  rescue JSON::ParserError
    raise StandardError.new("Invalid JSON response")
  rescue => e
    raise StandardError.new("Request error: #{e.message}")
  end
end

# Usage
begin
  domain = "example.com"
  result = check_domain(domain)
  
  if result['status'] == 'blocked'
    puts "#{result['domain']} is blocked in Indonesia"
  else
    puts "#{result['domain']} is accessible in Indonesia"
  end
rescue StandardError => e
  puts "Error: #{e.message}"
end