Technology

Local Network Packet Analysis Tool for API Inventory

Local Network Packet Analysis Tool for API Inventory

In Taiwan’s business environment, many organizations have strict data security requirements and prefer to keep sensitive network data within their premises. This tool addresses these specific needs by providing a local solution for API inventory management API .

Key Features

100% Local Processing

All packet analysis happens on your local machine, ensuring that your network traffic never leaves your infrastructure.

No Cloud Upload

Unlike SaaS solutions, your PCAP files remain securely stored within your local environment. No external servers, no third-party data sharing.

API Inventory Discovery

Easily identify and catalog internal APIs running within your network, providing full visibility into API communications.

Compliance Friendly

This tool aligns with local data protection preferences and security policies in Taiwan, making it an ideal choice for enterprises handling sensitive data.

Approach & Implementation

Frontend: React-Based UI

The front end is built using React 19, leveraging modern UI frameworks for a smooth user experience. The key dependencies include:

1
2
3
4
5
{
  "react": "^19.0.0",
  "react-dom": "^19.0.0",
  "react-scripts": "5.0.1"
}

To improve performance, we are considering migrating to Vite instead of Create React App.

Backend: FastAPI-Powered API Processing

The backend is built using FastAPI, a high-performance Python framework that enables rapid development and efficient processing. Key advantages include:

  • Asynchronous processing for handling large volumes of network traffic efficiently.
  • Automatic OpenAPI documentation for seamless integration with API tools.
  • Integrated Pydantic validation to ensure data accuracy and security.

Example FastAPI endpoint for processing PCAP files:

1
2
3
4
5
6
7
8
9
10
from fastapi import FastAPI, UploadFile, File
import scapy.all as scapy

app = FastAPI()

@app.post("/upload-pcap/")
async def upload_pcap(file: UploadFile = File(...)):
    content = await file.read()
    packets = scapy.rdpcap(content)
    return {"total_packets": len(packets)}

Packet Analysis & API Discovery

The tool processes PCAP files locally, extracting API-related metadata such as endpoints, methods, and response times. The backend uses Scapy (Python) or Tshark to analyze network traffic in real-time without exposing sensitive data externally.

Data Visualization

To provide insights into API traffic, the frontend includes interactive dashboards powered by Recharts or D3.js, allowing users to visualize:

  • API request volume
  • Response latency
  • Error rates

GitHub Repository

The source code for this project is available on GitHub:
View on GitHub

Feel free to explore, contribute, or raise issues!

Stay tuned for more updates on this API security tool! If you’re interested in a demo or have feedback, feel free to reach out.