Named after Argus Panoptes, the all-seeing giant with a hundred eyes from Greek mythology
ArguX is an advanced OSINT tool designed for gathering and analyzing publicly available camera feeds. It connects to publicly available sources like Insecam, applies object detection using YOLOv11 models to identify objects such as cars, people, and more, then visualizes the results through an intuitive web interface.
ArguX is a signifi 8000 cant evolution from my previous project EagleEye, which was a command-line tool using YOLOv4. While EagleEye laid the groundwork, ArguX completely reimagines the concept with a modern architecture, web interface, and significantly expanded functionality.
Interactive visualization of camera feeds across the globe
- High Performance Processing: Utilizes Celery integrated with Redis to efficiently distribute tasks among different threads
- Advanced Object Detection: Provides different sizes of YOLOv11 (nano, small, medium, large) for optimal performance based on your hardware
- Easy Setup: Simple configuration and intuitive user interface
- Rich Visualization: Multiple formats of data visualization (3D globe, charts, lists) with comprehensive filtering and sorting capabilities
- Geolocation Analysis: Fetches and maps geolocation information about camera IPs using ip-api.com
- Real-time Results: WebSocket-based live updates as cameras are analyzed
- Flexible Scanning: Filter camera sources by country or scan globally
Comprehensive filtering and sorting options for detected objects
ArguX is built using a modern tech stack:
- FastAPI - High-performance API framework
- Celery - Distributed task queue
- Redis - In-memory data store and message broker
- Ultralytics YOLOv11 - State-of-the-art object detection
- OpenCV - Computer vision processing
- Beautiful Soup - Web scraping
- Vite.js - Next generation frontend tooling
- React 19 - UI framework
- TypeScript - Type-safe JavaScript
- Three.js & react-three-fiber - 3D globe visualization
- Recharts - Charting library
- Tailwind CSS - Utility-first CSS framework
- Zustand - State management
Graceful error handling and detailed feedback
- Python 3.10+
- Node.js 18+ and npm
- Redis server
- Git (for cloning the repository)
-
Clone the repository:
git clone https://github.com/erfangolpour/argux.git cd argux -
Set up a Python virtual environment:
cd backend python -m venv .venv source .venv/bin/activate # On Windows: .venv\Scripts\activate
-
Install Python dependencies:
pip install -r requirements.txt
- Install Node.js dependencies:
cd frontend npm install
-
Install Redis server:
On Ubuntu/Debian:
sudo apt update sudo apt install redis-server sudo systemctl enable redis-serverOn macOS (using Homebrew):
brew install redis brew services start redis
For other platforms, please refer to the Redis documentation.
The backend settings can be configured in backend/settings.py:
- Adjust Redis connection settings (
redis_host,redis_port,redis_db) - Configure YOLO model settings (
default_model,yolo_base_dir) - Set maximum concurrent tasks (
max_concurrent_tasks) - Modify CORS settings for development/production environments
You can also create a .env file in the backend directory to override any settings:
LOG_LEVEL=INFO
MAX_CONCURRENT_TASKS=5
DEFAULT_MODEL=yolo11m.pt
-
Start the Redis server (if not already running as a service):
redis-server
-
Start the Backend API (from the backend directory):
uvicorn main:app --reload
-
Start the Celery worker (from the backend directory):
celery -A main.celery_app worker
-
Start the Frontend development server (from the frontend directory):
npm run dev
For convenience, a run.sh script is provided that uses tmux to run all services in a single terminal window:
chmod +x run.sh
./run.shThis will create a tmux session with separate panes for the backend API, Celery worker, and frontend development server.
While ArguX is not officially tested on Windows, it should be possible to run with proper configuration:
- Ensure Redis is installed and running (through WSL or Windows binary)
- Start each service in a separate command prompt:
- Backend API:
python -m uvicorn main:app --reload - Celery worker:
celery -A main.celery_app worker --loglevel=info --pool=solo - Frontend:
npm run dev
- Backend API:
ArguX is continuously evolving. Planned features include:
- Data Export: Capability to export results in various formats
- Persistent Database: Storage system for scan results for easy recall and historical analysis
- Custom Object Detection: Add custom objects to the detection model by re-training YOLO
- Better Backend-Celery Synchronization: Improve communication and avoid busy loops
- Optional Redis: Make Redis an optional dependency by allowing Celery to manage threads directly
- Additional Sources: Integration with more camera sources (Shodan, Censys, Criminal IP, ZoomEye, public highway indexes, etc.)
While not a requirement, Flower is an excellent open-source tool for monitoring and managing Celery clusters. To use it:
pip install flower
celery -A main.celery_app flowerThis provides a web interface at http://localhost:5555 for monitoring task execution.
It's important to understand that object detection models have inherent limitations. While YOLO is effective at identifying common objects like cars, people, or animals, it has limitations:
- Even the smallest YOLO models, despite being extremely efficient and fast, still need processing time, especially given the scale at which ArguX operates
- Detection accuracy is dependent on feed quality, lighting conditions, and distance
- Results should always be verified by a human
Contrary to popular belief, facial recognition is significantly more demanding than object detection and is simply not feasible at the current resolution of public camera feeds. So to answer the frequently asked question: this tool cannot be used to find specific people.
ArguX connects to camera feeds that are accessible through public directories like Insecam, which may include:
- Cameras with default credentials that haven't been changed
- Improperly secured camera feeds
- Cameras intentionally made public by their owners
It's important to understand that while these feeds are accessible to the average user through directory websites, this doesn't always mean they were intentionally made public by their owners. When using ArguX:
- Respect privacy and legal regulations in your jurisdiction
- Do not use for surveillance or monitoring individuals
- Do not share or publish content that contains private or sensitive information
As the creator of ArguX, I provide this tool strictly for research and educational purposes. I assume no liability and am not responsible for any misuse, illegal application, or damage caused by ArguX or modified versions of it. Users are solely responsible for ensuring their use of ArguX complies with all applicable laws and ethical standards.
Contributions to ArguX are welcome! Please follow these steps:
- Fork the repository
- Create a feature branch:
git checkout -b feature/awesome-feature - Commit your changes:
git commit -am 'Add awesome feature' - Push to the branch:
git push origin feature/awesome-feature - Open a Pull Request
Please ensure your code follows the project's coding style and is properly tested.
ArguX is licensed under the GNU General Public License v3.0 - see the LICENSE file for details.
- Ultralytics for their incredible YOLO implementation
- Insecam for aggregating publicly available camera feeds
- ip-api.com for providing geolocation data
- Celery for the distributed task queue framework
- FastAPI for the high-performance API framework
- All the open-source libraries and tools that make ArguX possible