An open-source Python HAR analyzer that reconstructs the state dependencies behind a target API request.
Browser DevTools can show you every request a page made. Charles Proxy and Burp Suite can show you the same traffic in much greater detail. But when one request succeeds only because five earlier requests prepared its cookies, tokens, and headers, the traffic log leaves a harder question unanswered:
Why was this request able to work?
That question becomes painful in a large HAR file. A target request may depend on a session cookie returned during login, a token embedded in a response body, a value that changed twice, and a header whose visible form has been URL-encoded or prefixed with Bearer. The requests are all there, but the dependency chain is hidden inside their values.
I built Reqvexa to trace that chain.
Reqvexa is an open-source HTTP provenance analyzer. Give it a HAR file, select a target request, and it searches earlier traffic for the values that made the target possible. It then expands those relationships recursively into the smallest request flow supported by the capture.
Reqvexa keeps supported, hypothetical, and unresolved values visible while masking sensitive values by default.
The problem hidden inside a HAR file
Imagine that the request you care about is:
POST /api/products
It contains a session cookie, an access token, a CSRF token, and a custom signature. Looking at that request tells you what was sent. It does not tell you where each value came from.
A representative Reqvexa result looks like this:
Target: POST /api/products
Required state
session <- POST /login SUPPORTED
csrf_token <- GET /csrf SUPPORTED
access_token <- POST /refresh SUPPORTED
x-signature <- not observed UNKNOWN
That state graph can then become a minimal prerequisite flow:
POST /login
-> GET /csrf
-> POST /refresh
-> POST /api/products
Unrelated images, analytics calls, fonts, and API requests are left outside the flow unless their responses actually contain a required value.
This is the difference between inspecting browser traffic and understanding HTTP request dependencies.
Reqvexa searches for values, not field names
The central idea is intentionally simple.
If the target contains:
Authorization: Bearer eyJhbGciOi...
Reqvexa does not search earlier traffic for the word Authorization. It searches for the runtime token value itself.
The same rule applies to cookies, query parameters, form fields, and nested JSON values. A field named csrfToken is not useful evidence by itself. Finding its exact value in an earlier response is.
Reqvexa treats earlier response material as searchable text, regardless of whether it came from JSON, HTML, plain text, a response header, or a cookie. This avoids making provenance depend on a response MIME type or a particular JSON schema.
It also checks common alternate representations:
- The value as captured.
- URL-decoded forms.
- Base64 and base64url forms.
- Authorization values with and without the
Bearerprefix. - Structured Base64 content, including useful JSON keys and values when the complete structure is not present.
Only traffic that occurred before the request being analyzed is eligible as a source. That temporal boundary both improves accuracy and avoids scanning irrelevant future traffic.
From one match to the complete request flow
Finding one token is only the beginning.
Suppose Reqvexa finds the target access token in the response from /refresh. The /refresh request may itself require an older refresh token. Reqvexa analyzes that producer request next, finds the earlier response that supplied its state, and keeps walking backward.
Conceptually, the graph is:
request -> response -> value version -> request
This matters when values change during a session. Reqvexa tracks temporal versions instead of assuming that every cookie or header with the same name is the same state. A newer session value should not be attributed to a response that only contained an older one.
The result is an evidence-bearing flow, not a guess based on URL names or request proximity.
The Analysis tab isolates the requests required by the traced flow and keeps their request and response data available for inspection.
Supported evidence is different from a hypothesis
Traffic analysis tools can become misleading when every correlation is presented as certainty. Reqvexa makes the distinction visible:
SUPPORTED
producer: POST /login
evidence: compatible value found in an earlier response
UNKNOWN / HYPOTHETICAL
source: not established by this capture
evidence: request-side value with no matching earlier response
SUPPORTED means the capture contains evidence for the relationship. UNKNOWN does not mean the value is invalid. It means the HAR file does not reveal its source.
An unresolved value may have been generated by client-side JavaScript, loaded before recording began, derived cryptographically, or stored outside the captured flow. Reqvexa keeps it unresolved instead of inventing a producer.
That distinction is especially useful during API reverse engineering and browser automation work: it tells you which parts of a workflow are explained by network evidence and which parts still require investigation.
A desktop workflow for large captures
Reqvexa includes an optional Flet desktop interface designed for working through real traffic:
- A Traffic tab lists captured requests and opens the request and response side by side.
- A Logs tab streams analysis progress while the scan is running.
- An Analysis tab appears as soon as analysis starts and fills with discovered results.
- Each analysis gets its own tab containing only the requests required for that flow.
- Values can be ignored and the analysis can be rerun without them.
- Sensitive values are masked by default and can be revealed deliberately during local inspection.
- Long response bodies are bounded so that accidentally opening a large JavaScript file does not freeze the interface.
- Analysis can be stopped while it is running.
The CLI exposes the same core engine for scripts and repeatable reports.
Try Reqvexa with the included synthetic capture
Reqvexa currently requires Python 3.12 or newer. The repository includes a synthetic HAR fixture, so you can try it without sharing or recording real traffic.
git clone https://github.com/kareemheshaam/Reqvexa.git
cd Reqvexa
python -m venv .venv
Activate the environment on Linux or macOS:
source .venv/bin/activate
Or on Windows:
.venv\Scripts\Activate.ps1
Install the project with its GUI dependency and open the fixture:
python -m pip install -e ".[gui]"
reqvexa gui fixtures/minimal.har.json
For the command line workflow:
reqvexa analyze fixtures/minimal.har.json
reqvexa trace fixtures/minimal.har.json --request REQUEST_ID
reqvexa plan fixtures/minimal.har.json --request REQUEST_ID
reqvexa report fixtures/minimal.har.json --request REQUEST_ID --format markdown
The included example resolves an observed session value and leaves an unobserved signature value unknown. That small fixture demonstrates the most important behavior: explain what the evidence supports and preserve what it does not.
Where Reqvexa is useful
Reqvexa is built for developers who need to understand stateful HTTP workflows, including:
- Debugging a multi-step authenticated API flow.
- Finding where cookies and tokens first appeared.
- Reducing a large browser capture to the requests required by one operation.
- Investigating why a replayed request is missing state.
- Documenting request dependencies for QA, scraping, or browser automation.
- Comparing observed server-provided values with unresolved client-side state.
It analyzes the capture locally and does not send requests to the recorded site.
What the alpha does not claim to do
Reqvexa is currently an alpha release focused on explanation. It does not yet replay requests, generate an API client, record a browser session, execute JavaScript, or reconstruct cryptographic signatures.
Those boundaries are deliberate. Before automating a workflow, I want the tool to produce a request plan whose dependencies can be inspected and defended with evidence.
The current release includes 28 tests and 16 deterministic synthetic benchmark cases. The benchmark is a regression suite, not a claim that every real-world HAR can be fully resolved.
Open source and looking for real feedback
Reqvexa is available under the MIT license:
GitHub: kareemheshaam/Reqvexa
If state provenance would help your debugging or automation workflow, try the synthetic fixture, inspect the implementation, and open an issue for a reproducible case the engine does not cover. A star also helps other developers discover the project while it is still young.
Browser traffic already tells us what happened. Reqvexa is an attempt to make it explain why.


Top comments (0)