Proxy
VirtuProbe includes a built-in MITM proxy that sits between your client and the target server. A DevTools-style UI lets you inspect every exchange in real time, including raw bodies, decompressed payloads and binary frames.
The proxy understands more than HTTP. It recognizes the protocol on each connection that passes through it and decodes it, so the capture feed labels an exchange as SMTP, DNS or MySQL rather than raw bytes. From a captured exchange you can draft a mock in one click. Everything reaches the proxy the same way, through a SOCKS5 tunnel. HTTP is recognized and acted on behind it like any other protocol.

Starting the proxy
Section titled “Starting the proxy”Set the Port the proxy should listen on in the toolbar, then click Start. Point your client at localhost on that port as a SOCKS5 proxy.
| Setting | Default |
|---|---|
| Host | localhost |
| Port | 1080 |
Any TCP client works: a mail client, a DNS resolver, a database driver or a browser. Route its connection through the tunnel and the proxy decodes whichever of the protocols below it recognizes.
Protocols the proxy decodes
Section titled “Protocols the proxy decodes”The proxy recognizes and decodes these protocols on the connections that flow through it:
HTTP, SMTP, IMAP, LDAP, DNS over TCP, FTP, MySQL, PostgreSQL, SQL Server, MongoDB, Redis, SMB, Kerberos and STOMP (ActiveMQ).
Each exchange is tagged with its protocol in the capture feed (an HTTP exchange with its method). The text protocols read as text; the binary ones render as a hex view next to a decoded summary. A connection without TLS that the proxy does not recognize is relayed unchanged and shown as raw bytes. A connection that starts with TLS is always terminated by the proxy (see SSL/TLS traffic), whether or not its protocol is recognized.
Most protocols are recognized by what the client sends first, on any port. Four are recognized by port instead, because their clients wait for the server to speak first, so a session of one of these on any other port is relayed without being decoded:
| Protocol | Ports |
|---|---|
| SMTP | 25, 465, 587 |
| IMAP | 143, 993 |
| FTP | 21, 990 |
| MySQL | 3306 |
Inspecting exchanges
Section titled “Inspecting exchanges”Each exchange appears in the capture feed as it flows through the proxy, tagged with its protocol (an HTTP exchange with its method instead) and with its status when it has one. When an interception rule acts on an exchange, the feed marks it with the action it took (MOCK, FAULT:RESET and so on). Hovering the mark names the rule. An SMB or Kerberos reset is not marked. Click an entry to inspect it.
The detail panel splits into two halves:
- Request: the bytes sent by the client
- Response: the bytes returned by the server
Each half has a Parser selector that chooses how to decode the bytes, plus a button to copy them.
For an exchange of a recognized protocol, the Session view lists every message of its session in the order they were captured. Its button sits between Traffic and MCP, the view of intercepted MCP tool traffic. Each message shows its one-line summary, with its Decoded fields in an expander below. An HTTP message has a summary (its request or status line) and no decoded fields. A streamed HTTP body appears as one row per chunk without a summary.
SMTP: the decoded email
Section titled “SMTP: the decoded email”The decoded email appears on the row that completes the email, whether the client sent it with DATA or in BDAT chunks. That row shows, in place of the Decoded fields expander:
- the From, To, Cc, Subject and Date of the email
- a one-line outline of how its parts nest
- the parts, each with its type, decoded size and transfer encoding, plus its file name when it declares one and its charset when it is a text part
- the content of each text part
Text appears decoded from its transfer encoding and its charset. An HTML part shows its source rather than a rendered page. The content of a text part is cut after 65,536 characters with a note saying so.
A warning above the parts lists what the proxy could not show in full or as the email declares it:
- base64 that does not decode, in which case the part is shown as it was sent
- an unknown charset, in which case the part is read as UTF-8
- a multipart without a boundary, which is shown as one part
- a multipart without its closing boundary, whose last part may be incomplete
- more than 64 parts, past which the rest are not listed
- more than 64 headers, which does not hide the five shown above
- parts 8 or more levels below the top of the email, which are not opened and are left out of the list of parts
- an email that could not be read to the end, in which case the header fields and the parts read up to that point are still shown
- an email larger than 8 MiB, which is decoded from its first 8 MiB and still reaches the server whole
IMAP: responses labeled with their command
Section titled “IMAP: responses labeled with their command”A tagged completion names the command it answers in its answers field. An untagged response or a + continuation names the open command in its inResponseTo field, but only while exactly one command is open. In both fields a UID command appears with its subcommand, such as UID FETCH. The client’s message for that command reads just UID in its command field, which is the value an interception rule matches.
LDAP: decoded operations
Section titled “LDAP: decoded operations”Each operation is decoded with its message ID:
- a bind with its DN, plus the mechanism of a SASL bind
- a search with its base, scope, filter and requested attributes, then every entry and referral it returns
- a modify with its DN and each change with its kind (
add,deleteorreplace) and the attribute name - an add with its DN and the names of its attributes
- a delete with its DN
- a modify DN (a rename or a move) with its DN, the new RDN and any new parent
- a compare with its DN, the attribute and the value it asserts
- an abandon with the message ID it cancels
- an extended operation with its OID
- the server’s answer to each operation that has one, with its result code by name, the matched DN and the diagnostic message
A simple bind’s password shows only as set or empty in the Decoded fields. The capture still keeps the raw bytes the client sent, credentials included, as it does for every protocol.
Body decompression
Section titled “Body decompression”Set a request’s or response’s Parser to HTTP, then tick Decompress body beside it to read a gzip, deflate or Brotli body. A REWRITE rule that changes a gzip, deflate or Brotli body decompresses it first and sends the result uncompressed.
SSL/TLS traffic
Section titled “SSL/TLS traffic”The proxy terminates every connection that starts with TLS, so a client that verifies the certificate it is shown has to trust the proxy CA. When a client offers application protocols (ALPN) in the handshake of a connection that starts with TLS, the proxy accepts http/1.1, postgresql or tds/8.0 (the last two for the PostgreSQL and SQL Server clients described below). A client that offers HTTP/2 beside HTTP/1.1 talks HTTP/1.1 through it, while one that offers none of these names cannot connect. A client that offers no application protocol is not affected. Implicit TLS (SMTP on 465, IMAP on 993, FTPS on 990, LDAPS on 636) is handled like HTTPS.
Sessions that upgrade to TLS part way through are intercepted too. SMTP, IMAP and LDAP upgrade with STARTTLS. FTP upgrades with AUTH TLS. When the server accepts the upgrade, the proxy opens its own TLS connection to the server and completes the client’s handshake with a certificate signed by the proxy CA, so everything after the upgrade still appears decoded in the capture feed.
PostgreSQL, MySQL and SQL Server also upgrade to TLS part way through, inside their own protocol. The proxy intercepts those upgrades the same way. The TLS starts:
- for PostgreSQL, when the server answers the client’s
SSLRequestwithS - for MySQL, when the client sends its
SSLRequest - for SQL Server, when the client and server agree to encrypt the whole session or only the login
A libpq client asks for GSS encryption by default when it holds a Kerberos ticket. Its connection is then relayed without being decoded, whatever the server answers. That includes a session that falls back to TLS or to plaintext after the server declines GSS. Connect with gssencmode=disable to have the session decoded.
A libpq client set to sslnegotiation=direct starts with TLS and offers postgresql as its application protocol. A SQL Server client in strict encryption (encrypt=strict in the Microsoft JDBC driver) does the same with tds/8.0. The proxy accepts both, offers the same name to the server and decodes the session from its first message. The server has to support the mode as well. sslnegotiation=direct works against PostgreSQL 17 or later. Strict encryption needs a TLS certificate configured on the SQL Server. On Linux strict encryption worked with SQL Server 2025. SQL Server 2022 on Linux refused it even with a certificate configured, logging error 17821 on the server and closing the connection.
A libpq client such as psql binds a SCRAM login to the TLS certificate it sees unless told otherwise. The PostgreSQL JDBC driver does the same in version 42.7.4. Through the proxy that certificate is signed by the proxy CA, so the server rejects the login with SCRAM channel binding check failed. The Session view shows a warning naming the cause and the fix under the client’s login message and under the server’s refusal. To log in through the proxy, turn channel binding off: channel_binding=disable for libpq, channelBinding=disable for the PostgreSQL JDBC driver.
Whichever way the TLS starts, the proxy checks that the server’s certificate chains to a CA VirtuProbe trusts and is issued for the host. An FTP data connection protected with PROT P is opened to the address the server named for it but carries the certificate of the FTP server, so the proxy checks it against the control connection’s host. The installed desktop app on Linux trusts the system’s Java CA store at /etc/ssl/certs/java/cacerts when that file exists and is not empty, including any CA your administrator has added there. On macOS, on Windows and on Linux without that store it trusts only the public CAs bundled with the app. An execution server deployed as a Docker image trusts the CAs of its own Java runtime. When the check fails, an HTTPS client gets a 502 Bad Gateway from the proxy and any other client sees the connection close.
A self-signed or private-CA server can still be reached. Open Upstream certificates from the proxy toolbar to see each refused certificate with its host, subject and the reason it was refused. Choose Trust this certificate, compare the SHA-256 fingerprint in the dialog with the one the server’s owner gives you, then confirm with Trust certificate. From then on the proxy accepts that exact certificate for that host. Any other certificate from the same host still has to pass the normal check.
A trusted certificate is kept by the VirtuProbe that runs the proxy, so with a separate execution server it applies on that server for everyone who uses it. To undo it, choose Stop trusting this certificate in the list of trusted certificates.
HTTP through the tunnel
Section titled “HTTP through the tunnel”The proxy terminates and parses each HTTP/1.1 request, with HTTPS handled by an on-the-fly leaf certificate signed by the proxy CA. Because it understands whole requests and responses, it can act on them with interception rules.
With no rules defined, every request is forwarded to the real target and still appears in the capture feed.
A response that is chunked or runs until the server closes it is passed on as it arrives, so a stream of server-sent events keeps streaming. The proxy collects the whole response and sends it with a Content-Length only for a REWRITE or MCP_POISON rule, a fault, a rule decided on the response status and a request carrying an MCP (JSON-RPC) message, since each of those has to read all of it.
Interception rules (mocking & service virtualization)
Section titled “Interception rules (mocking & service virtualization)”Interception rules turn the proxy into a service virtualization layer: match live requests and mock, rewrite, delay or script their responses. Manage them from the Interception Rules editor in the proxy view.

Rules are organized into rule sets, which are stored with your installation and survive restarts. Within a set, rules are evaluated top to bottom and the first match wins, so order matters (use the arrows on a rule to move it up or down). Each rule has a match and an action.
Also apply to outgoing traffic is switched on in a new rule set and off in an imported one. When a rule set is switched on and has that switch on, its rules are matched against the requests VirtuProbe itself sends from probes, chains and scripts too, whether the proxy is running or not. The hint below the switch names the protocols this covers. Not every rule can act on such a request, since most of them change a real response and there is none. The editor tags each rule in the set that will not act on VirtuProbe’s own requests Proxy only.
Matching
Section titled “Matching”Every match field is optional; a blank field matches anything. A rule fires when all of its filled-in conditions match:
| Field | Matches on |
|---|---|
| Method | HTTP method (GET, POST, …) |
| Host pattern | Request host, supporting {segment} placeholders and * wildcards |
| Path pattern | Request path, supporting {segment} placeholders and * wildcards |
| Header name / Header value contains | A request header and (optionally) a substring of its value |
| Body contains | A substring of the request body |
| Response status | The status the target answered with, as a code (404), a class (5xx) or a range (500-504), several separated by commas |
A rule with a Response status is decided on the target’s answer, while its other fields select the request as usual. Among the matching rules above the first one without a Response status, in order across the rule sets that are switched on, the first whose Response status the answer meets handles it. When none does, that first rule without a Response status handles it. A MOCK rule with the Response status 5xx therefore replaces a server error from the target.
Such a rule applies only to a request that reached the target, so never to one answered by a MOCK or SCRIPT rule or ended by a drop or reset fault. The request has already gone by the time the status is known, so the editor disables adding Request rewrites to such a rule and saving refuses a rule that has both.
Actions
Section titled “Actions”| Action | What it does |
|---|---|
MOCK | Return a synthetic response you define, with its own status, reason, Content-Type, headers and body, without the request ever reaching the real target (with a Response status, it replaces the target’s answer instead). Stand in for a service that isn’t built yet. The response can echo the request through template variables. |
FORWARD | Pass the request through to the real target unchanged (the default behavior when no rule matches). |
REWRITE | Forward to the target and change the live traffic with SET, REPLACE and REMOVE operations on a request’s headers, body, method or path and a response’s headers, body or status. On a body or path, SET replaces the whole value, REMOVE empties it and REPLACE looks for its Find text, optionally as a regular expression. On a header, method or status, SET and REPLACE both set it to Value. Find and Value can use template variables. |
FAULT | Inject one of the faults to exercise how your client handles failure. |
SCRIPT | Run a JavaScript script with a copy of the request as request (method, path including its query string, body, headers, host, port, secure) and a mutable response (status, reason, headers, body). Changes to request are ignored. Mutate the response or return a map to build a dynamic mock that reacts to the request. With a Response status, the script’s answer replaces the target’s instead. |
MCP_POISON | Forward to an MCP server, then inject a prompt-injection payload into its answer. The payload can extend or replace a tool’s description, add a tool the server never advertised or replace the text of a tool call’s result. Use it to watch whether your own agent obeys hostile text from a server it already trusts. |
Every action takes a Latency (ms) delay and a Jitter (ms) that adds a random extra of up to that many milliseconds, each up to 60000 ms and never more than 60000 ms together. A MOCK, SCRIPT or FORWARD rule and a fault that drops or resets the connection wait before handling the request. Every other rule waits after the target answers, before the response reaches the client, as does any rule with a Response status and a FORWARD rule below one.
A Probability (%) below 100 makes a rule act on only that share of the requests it matches while the next rule is tried for the rest. A FAULT rule at 10% above a MOCK rule faults about one request in ten and mocks the others.
Faults
Section titled “Faults”A fault changes how the real response arrives or ends the connection without one:
| Fault | What the client sees |
|---|---|
| Latency only | The real response, after the latency set on the rule |
| Error status | The real response with your status, reason and (if set) body in place of the server’s |
| Empty body | The real status and headers with no body |
| Garbage body | Random bytes of the same length in place of the body (64 bytes when the real body is empty) |
| Truncated body | The real headers, keeping the declared length, then only the Body bytes sent before the connection closes |
| Slow drip | The whole real response in chunks of Bytes per chunk, separated by Pause between chunks (ms) |
| Drop the connection | The connection closes without a response; unless the rule has a Response status, the target is never contacted |
| Reset the connection | The connection is reset (TCP RST) without a response; unless the rule has a Response status, the target is never contacted |
Template variables
Section titled “Template variables”{{name}} placeholders filled from the request can go into a MOCK rule’s body, header values, reason and Content-Type as well as into a REWRITE operation’s Find and Value:
| Placeholder | Value |
|---|---|
{{id}} | The text a {id} segment matched in the path or host pattern (any name made of letters, digits and underscores) |
{{request_method}}, {{request_path}}, {{request_query}}, {{request_host}}, {{request_body}} | The request’s own method, path, query string, host and body |
{{query_page}} | A query parameter, here page |
{{header_x_request_id}} | A request header, here X-Request-ID, lowercased with every character other than a letter, digit or _ turned into _ |
A placeholder that names nothing is left as written, so a body that happens to contain {{ reaches the client unchanged.
Import rules from a spec
Section titled “Import rules from a spec”Click Import from spec in the Interception Rules editor and pick OpenAPI / Swagger, HAR or WSDL. The document becomes a rule set of MOCK rules:
- an OpenAPI operation answers with its first 2xx response (without one, its
defaultor first declared response) and that response’s example - a HAR capture gives one rule per method, host and path, answering with the first response recorded for it
- a WSDL operation answers with an empty SOAP response for you to fill
The imported set starts switched off.
Add a mock from a captured exchange
Section titled “Add a mock from a captured exchange”You do not have to write a mock rule from scratch. Select a captured exchange and click Add Mock. VirtuProbe drafts a matching mock rule from it, pre-filled and tagged with the protocol it captured. You review the draft before you save it into a rule set.
Add Mock is available for HTTP, SMTP, IMAP, LDAP, DNS, FTP, STOMP, Redis and the database protocols (MySQL, PostgreSQL, SQL Server, MongoDB). SMB and Kerberos are decoded but cannot be mocked, so they offer no Add Mock. In the Interception Rules editor you can still give them a FAULT rule matched on the host, which resets the connection.
A Redis draft answers the captured command with the server’s real reply. An LDAP session is one exchange in the capture feed, so its draft answers the session’s first request that expects an answer (usually the bind) with the server’s real result. Both can be saved as they are.
The proxy connects to the directory only once a request has to reach it, so with no directory reachable every request in the session that expects an answer has to match a mock. To mock a search as well, add a second rule beside the bind’s with the operation SEARCH and the DN cleared (or set to the search base). List its entries the way LDIF writes them, each a dn: line followed by attribute: value lines and separated from the next by a blank line. An entry without a dn: line is left out. Check the bind rule’s result code as well, since a draft taken from a failed bind still carries that failure.
The database drafts start from an error and need editing before they return data:
- PostgreSQL, MySQL and SQL Server drafts start as an authentication error on the login (message type
STARTUP,HANDSHAKE_RESPONSEorLOGIN7). To return a result set you choose, switch the action toRESULTand change the message type to a query (QUERYfor PostgreSQL and MySQL,SQL_BATCHorRPCfor SQL Server). - The MongoDB draft answers every command sent to that server with an authentication failure. Switch the action to
RESULTand narrow it by the command name (find, for example).
Save a capture as a probe
Section titled “Save a capture as a probe”Save as Probe is available for HTTP, SMTP, IMAP and LDAP. For HTTP it drafts the selected request. For SMTP, IMAP and LDAP it drafts the whole session the selected exchange belongs to as one probe, because a single command out of a mail or directory session rarely runs on its own. Each command in it expects the code the server answered, including a refusal (for IMAP the status, for LDAP the result code), so running the probe checks that the server still answers the way it did. An LDAP probe keeps the session’s binds, searches, compares, deletes and unbinds, while any other operation, such as a modify or an add, stays in the capture feed only.
An HTTP probe keeps the request as captured, including its Authorization header and cookies, so remove them before you share the probe and set its Auth to a stored credential instead.
An SMTP, IMAP or LDAP probe never receives the session’s credentials. AUTH, LOGIN and AUTHENTICATE commands are dropped, while an LDAP bind keeps its DN without the password. Against a server that requires a login, an SMTP or IMAP probe therefore needs its login command added. An LDAP bind needs its password or a stored credential.
Add a capture to a chain
Section titled “Add a capture to a chain”Add to chain sits beside Save as Probe in the toolbar and in an exchange’s context menu, for the same protocols. It saves the capture as a probe from the same draft Save as Probe uses and adds that probe to a chain as a linked step. The probe is named after the session, SMTP session mail.example.com for example.
Pick an existing chain of the active project or create a new one. A new chain goes into the bundle you choose or, if you choose none, into the Default bundle of the active project (the global Default bundle when no project is active). If you leave the new chain’s name empty, it takes the probe’s name. The probe is saved in the chain’s bundle, so the step starts out pointing at a probe in the same projects as its chain. The chain then opens with the new step in view.
The step is added without a snapshot (the copy of the probe a linked step can fall back on), so it fails once the probe is deleted. To keep a step that works without the probe, use Detach to copy on it before you delete the probe.