What Are the Dependencies for GhostTrack? Complete Guide to Installation and Usage

GhostTrack relies on exactly two external Python packages: requests for HTTP networking and phonenumbers for phone number parsing, both declared in the project's requirements.txtfile.

GhostTrack is a lightweight Python OSINT utility developed by HunxByts that performs IP geolocation and phone number analysis. Unlike larger frameworks that pull in dozens of libraries, the source code in HunxByts/GhostTrack keeps its footprint minimal by depending only on two battle‑tested third‑party packages, while leveraging Python’s built‑in standard library for everything else. Understanding these dependencies is essential for secure deployment and troubleshooting import errors.

Complete Dependency List for GhostTrack

The repository defines its external requirements in the root‑level requirements.txt file. According to the source code analysis, only the following non‑standard libraries are required:

• requests – Handles all HTTP/HTTPS communication with external APIs (used in GhostTR.py for IP lookups)
• phonenumbers – Provides parsing, validation, formatting, and carrier/geolocation metadata for telephone numbers

All remaining functionality—such as JSON serialization, system calls, and CLI argument handling—is provided by the Python standard library (json, os, sys, time, etc.).

requests: HTTP Library for IP Lookup

The requests library enables GhostTrack to query external services to resolve public IP addresses and gather geolocation data. In GhostTR.py, the tool uses requests.get() to fetch data from endpoints like https://ipinfo.io/json.

Example: Fetching IP Data with requests

import requests

# Query a free IP-lookup service used by GhostTrack

response = requests.get("https://ipinfo.io/json")
data = response.json()
print(f"Your public IP is {data['ip']}")

This pattern appears throughout GhostTR.py whenever the script needs to contact remote servers, making requests the critical networking layer for the tool’s IP tracking features.

phonenumbers: Phone Number Parsing and Validation

The phonenumbers library (a Python port of Google’s libphonenumber) is responsible for normalizing user input, validating national and international formats, and extracting carrier and timezone metadata. The main script imports specific submodules including carrier, geocoder, and timezone from the package.

Example: Validating and Formatting Numbers

import phonenumbers
from phonenumbers import carrier, geocoder, timezone

user_input = "+1 555-123-4567"
default_region = "US"

# Parse the number according to local format rules

parsed = phonenumbers.parse(user_input, default_region)

# Validate before processing

if phonenumbers.is_valid_number(parsed):
    # Standardized formats

    e164 = phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164)
    intl = phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
    
    print(f"E.164 format: {e164}")
    print(f"International format: {intl}")
    
    # Metadata extraction

    print(f"Carrier: {carrier.name_for_number(parsed, 'en')}")
    print(f"Country: {geocoder.description_for_number(parsed, 'en')}")
    print(f"Timezone(s): {timezone.time_zones_for_number(parsed)}")
else:
    print("Invalid number")

This logic mirrors the implementation found in GhostTR.py, where phonenumbers.parse() and phonenumbers.is_valid_number() gate the execution of carrier and geolocation lookups.

How to Install GhostTrack Dependencies

Installing the dependencies for GhostTrack requires a single command using the provided requirements.txt file.

1. Clone the repository:

   git clone https://github.com/HunxByts/GhostTrack.git
   cd GhostTrack

2. Install the dependencies:

   pip install -r requirements.txt

The requirements.txt file pins the following packages:

requests
phonenumbers

Alternatively, you can install them explicitly:

pip install requests phonenumbers

Summary

• GhostTrack requires only two external dependencies: requests and phonenumbers.
• The requests library powers HTTP calls for IP geolocation lookups in GhostTR.py.
• The phonenumbers library validates, formats, and enriches phone number data using carrier and geocoder submodules.
• All other functionality relies on the Python standard library (json, os, sys, etc.).
• Install both packages via pip install -r requirements.txt from the repository root.

Frequently Asked Questions

Does GhostTrack work with Python 2?

No. As implemented in HunxByts/GhostTrack, the codebase uses Python 3 syntax and the phonenumbers library version compatible with modern Python 3 releases. You should use Python 3.7 or newer to ensure full compatibility with the dependency versions specified in requirements.txt.

Can I run GhostTrack without installing dependencies?

No. The script GhostTR.py imports requests and phonenumbers at the module level. If these packages are missing, the interpreter will raise an ImportError immediately upon execution. You must install the dependencies using pip install -r requirements.txt before running the tool.

What version of the requests library does GhostTrack need?

The repository does not enforce a strict upper bound in requirements.txt, but any recent stable version of requests (2.25.0 or higher) will satisfy the HTTP functionality used in the IP lookup routines. For security and performance, always use the latest stable release when installing the dependencies for GhostTrack.

Are there any optional dependencies for extended features?

No. The requirements.txt file lists only requests and phonenumbers, and the source code in GhostTR.py does not import any additional third‑party libraries. All extra features—such as colored terminal output or file handling—are implemented using the Python standard library alone.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}