WEBSOCKET TESTING GUIDE
WebSocket Testing in the Browser: Modify, Delay, and Drop Messages
Test WebSocket messages in Chrome using your app’s own connection. Modify payloads, delay or drop incoming messages, and save useful checks for repeat testing.
A live update can contain an unexpected value, arrive late, or never reach the page. WebSocket testing should show what your frontend does in each case: what it displays, how long it waits, and whether the user can continue.
Here you will use the application's own connection in Chrome, find a real incoming message, change its delivery, and trigger the application again. The Playground provides a small, repeatable example; use the same approach with the messages and expected behavior of your own feature.
VIDEO WALKTHROUGH
See wrong, late, and missing WebSocket messages in action
Watch how unexpected data, delayed replies, dropped messages, and outgoing WebSocket changes affect a real application — then follow the step-by-step guide below.
WebSocket testing with real application traffic · PayloadPigeon
Selecting Play loads YouTube’s privacy-enhanced player. YouTube then receives your connection data. Privacy details.
Watch on YouTube ↗Before you start
- Install PayloadPigeon in Chrome and use a normal Chrome window.
- Start Capture for the application tab before the application creates its WebSocket connection.
- If the connection already exists, disconnect and reconnect through the application after Capture starts.
- Message modification is available only for supported connections. Seeing traffic does not mean an already-open socket can be modified.
Inspect the application's WebSocket traffic first
Open the WebSocket Playground lesson. In the extension, select Start capture this tab. Then, on the page, click Connect, followed by Send message.
Open Traffic → WebSockets, select the active connection ending in /playground/ws, and wait for Testing available. Find the outgoing profile.updated message and its incoming profile.updated reply. The normal reply contains payload.role: "admin".

Select the incoming message and inspect its full JSON. In this example, type identifies the message type and payload contains the profile fields. The server echoes the sent JSON, and the page compares the real reply with the sent message. In your application, first identify the equivalent fields and the user action that produces the message.
Expected result: the Playground shows Reply matches sent message with no changes. Keep this normal response as your baseline.
Test incoming WebSocket messages with a different payload
Change one condition at a time. First change the payload; then try a delay with the normal payload; finally drop one reply. That makes it easier to connect a visible frontend reaction to the condition you introduced. If Ready prompts you to turn off an existing Test or Traffic action, confirm when you intend to replace that earlier scenario.
Change, replace, drop, or delay a message
Start by changing the message payload. Select the incoming profile.updated and open Modify & test. Keep Apply changes to fresh message, with Delay (ms) set to 0.
Edit the full JSON already in the Message editor: change only payload.role from admin to viewer. Leave type, the name, active flag and other displayed fields unchanged. The changes indicator should show one change.
Before: "role": "admin"
After: "role": "viewer"
These fragments illustrate the field being changed; they are not the full payload to paste into the editor. Keep the complete captured message in the editor.

Select Ready, then click Send message again on the same connected Playground page. Ready waits for the next matching incoming message; it does not click the page or ask the server to send anything.
Expected result: the page's received message contains payload.role: "viewer", and the Playground shows Reply differs from sent message. It shows the actual reply and a diff for payload.role. The connection stays open.

Compare the delivered message with the fresh server reply. Only payload.role should change; type stays profile.updated. App → Server is the outgoing message, and Server → App is the incoming reply.
Use Apply changes to fresh message for this scenario. It changes the selected field on the next matching message while preserving the remaining fresh values. Replacing the entire message instead uses the saved payload.
For your own frontend, check its specified fallback, error state, and recovery controls. Receiving the edited WebSocket payload proves delivery; the actual interface tells you whether the feature handled it correctly. For HTTP responses, use the same approach to test frontend edge cases with real API traffic, such as an expired subscription or a missing field.
Check what happens when a message arrives late
Send once without arming another change to obtain a normal reply with payload.role: "admin". Select that incoming message, open Modify & test, and leave the full payload unchanged. Keep Apply changes to fresh message, set Delay (ms) to 5000, select Ready, and click Send message again.

Expected result: the page shows Waiting for reply… while delivery is delayed. About five seconds later than the normal response, it shows Reply matches sent message, the unchanged reply, and the elapsed time. Check the waiting state as well as the eventual reply; total time includes normal processing and delivery.
This delays one matching message's delivery to the page. It does not simulate every effect of a slow network or slow down work the server has already performed.
Drop the next matching message
Start with a normal reply with payload.role: "admin" again. Open Modify & test, reset Delay (ms) to 0, choose Message behavior → Drop message, and select Ready. Trigger Send message on the page.
Expected result: the next matching reply does not reach the application. Check the extension's APPLIED / Message dropped indication and the page's Last Exchange, rather than assuming a missing UI update proves a drop. The Playground keeps Waiting for reply… with elapsed time, and Send message remains disabled.
Dropping one message does not close the WebSocket. To start a new exchange, choose Disconnect → Connect, keep Echo, and select Send message without arming Ready again. With no other change armed, the new exchange should receive its normal reply with payload.role: "admin". In your own application, check the timeout or recovery behavior required for a missing update.
Open WebSocket Playground to try these cases. Add to Chrome if you have not installed the extension.
Send outgoing WebSocket messages to check backend behavior
Select an outgoing App → Server · profile.updated in the same supported connection and open Modify & send. In the full message, change payload.role from admin to viewer, keep the other fields unchanged, and select Send.
Expected result: the edited message is sent through the real connection and the server echoes it. Inspect the corresponding Server → App reply in Traffic. An extension send does not repeat the page action; the Playground can compare this extra reply with its last application-message baseline. Outgoing modification uses Send.
Outgoing messages are real sends and may trigger real backend actions. A resend can repeat an operation or change data. Use an authorized development or staging environment with safe test data; the Playground example uses a bounded demo action.
Save WebSocket scenarios as reusable Tests
The harder part comes after the check
If a WebSocket scenario is worth checking again, save it instead of rebuilding it from memory. Use Save as Test, name the behavior you want to check, and complete the saved-data protection or unlock step if prompted. The usage guide explains that setup.
Build a regression suite around one feature
Group related checks in a Test Plan: normal update, changed role, delayed update, and dropped update. Keep a note of the required page state and expected reaction. The Plan groups manual checks; it does not run them automatically.

Complete a manual test run after the next change
Prepare the page and supported connection again. Use Ready and trigger the page for an incoming saved Test, or Send for an outgoing one. Inspect the application, then record Works correctly or Found a problem, with the expected and observed behavior. A temporary Traffic action does not become a historical Result retroactively: run the saved Test to record its outcome.

Use previous Results without treating old scenarios as permanent truth
Review message matching, changing identifiers, and the current requirements before repeating an old Test. PayloadPigeon does not automatically judge UI correctness. Learn how to turn saved manual checks into a reusable regression suite.
A standalone WebSocket client or the application's own connection?
Chrome DevTools is often enough to inspect WebSocket messages or troubleshoot the connection: open Network, select the WS filter, then the connection's Messages tab. It also supports WebSocket throttling; see the Chrome DevTools network reference.
A standalone WebSocket client is useful when you want to connect to an endpoint independently. PayloadPigeon is useful when you start from the running application's supported connection, change a message, observe the actual UI, and keep the scenario for later.
Where manual WebSocket testing fits alongside automation
Use these checks to investigate frontend behavior. They complement protocol, load, security, and automated testing. A stable, frequently repeated case may be worth automating; a saved Test Plan is not a full automation suite.
When a WebSocket connection is observe-only
Capture must start before a supported connection is created. If a socket already exists, reconnect through the application after starting Capture, send a suitable text/JSON message, and wait for identification.
Some worker-created, binary-only, unsupported, or ambiguously identified connections can remain observe-only. Reloading may help when the page cached the original WebSocket constructor before Capture, but it is not a universal fix. See the WebSocket support boundaries and usage troubleshooting.
Keep the checks, not just the traffic
Try the same scenario in the WebSocket Playground: capture a normal reply, change one field, trigger the page again, and inspect the result. Then save the checks that would be useful after your next frontend change.
Open WebSocket Playground, then build a reusable manual regression suite from the checks you saved.