ramforth/youtube-chat-webhook-v2
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Update README.md with research plan

Browse Source
This commit is contained in:
Ramforth
2025-10-30 17:03:16 +01:00
parent d4c83fb908
commit 9899b04dc0
1 changed files with 29 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
README.md
View File

@@ -1,68 +1,54 @@
# YouTube Chat Webhook Listener (Version 2)
# YouTube Chat Webhook Listener (Version 2) - Research Phase
This project aims to create a more robust and quota-friendly YouTube Live Chat monitor by leveraging third-party streaming services (like StreamElements) that provide webhook notifications for new chat messages. This approach avoids constant polling of the YouTube Data API, thus eliminating quota issues and providing near real-time chat updates.
This project is currently in a research phase to identify the most robust, quota-friendly, open-source, and Linux-compatible solutions for monitoring YouTube Live Chat. The goal is to gather comprehensive data to inform the development of a long-term solution that avoids the limitations of continuous API polling.
## Project Goal
To build a Python application that listens for chat message webhooks from a third-party service, processes them, and displays them in the terminal, effectively creating an event-driven chat monitor.
## Detailed Implementation Plan
To conduct deep research into various methods for obtaining YouTube Live Chat data, prioritizing open-source and Linux-compatible solutions, with a focus on minimizing or eliminating YouTube Data API v3 quota consumption for sustained live stream monitoring. The gathered information will be used by a separate AI product to inform future development.
### Phase 1: Setup Local Webhook Server
## Deep Research Plan
1. **Choose a Python Web Framework:** We will use `Flask` for its simplicity in setting up a basic web server.
* **Action:** Install Flask: `pip install Flask`
The research will focus on the following key areas:
2. **Create `webhook_server.py`:** This file will contain the Flask application.
* **Action:** Create `webhook_server.py` with a basic Flask app structure.
### **1. YouTube Data API v3 - Deeper Dive**
3. **Define Webhook Endpoint:** Implement a POST endpoint (e.g., `/chat-webhook`) that will receive JSON payloads from the third-party service.
* **Action:** Add `@app.route('/chat-webhook', methods=['POST'])` to `webhook_server.py`.
* **Focus:** Exhaustive search for official, quota-friendly API endpoints or features.
* **Key Questions:** Are there any less-documented ways to get live chat data? What are the exact quota costs for *all* relevant live streaming API calls? Are there any official recommendations from YouTube for long-term live chat monitoring? Can quota increases be requested?
4. **Parse Incoming Data:** The Flask app will need to parse the JSON data received from the webhook. The structure of this data will depend on the chosen third-party service (e.g., StreamElements).
* **Action:** Add logic to `handle_webhook()` to extract `username` and `message` from `request.json`.
### **2. Third-Party Webhook/Event-Driven Solutions**
5. **Queue Messages:** Instead of directly printing, the Flask app will put received messages into a Python `queue.Queue` object. This queue will be shared with the main display thread.
* **Action:** Implement a shared `queue.Queue` and add messages to it.
* **Focus:** Identify and analyze third-party services that provide webhook notifications for YouTube Live Chat.
* **Key Questions:** Which platforms offer YouTube Live Chat webhooks? How do they work, what are their limitations, and what are their costs? How do they bypass or manage YouTube's API quota?
6. **Run Flask App in a Separate Thread:** The Flask development server should run in a separate thread to avoid blocking the main application.
* **Action:** Implement `run_flask_app()` function and start it in a `threading.Thread`.
### **3. Unofficial/Scraping Methods**
### Phase 2: Integrate with Main Display Logic
* **Focus:** Investigate methods to obtain live chat data outside of the official API.
* **Key Questions:** Are there any known unofficial APIs or methods to scrape live chat data? What are the technical challenges, ethical considerations, and legality (YouTube's ToS)?
1. **Modify `main.py`:** The existing `main.py` will be adapted to become the display client.
* **Action:** Remove all YouTube Data API polling logic (`fetch_live_chat_messages`, `get_live_chat_id`).
### **4. Client-Side/Browser-Based Solutions**
2. **Start Webhook Server:** `main.py` will initiate the `webhook_server.py` in a separate thread.
* **Action:** Import `webhook_server` and start its Flask thread in `main()`.
* **Focus:** Explore methods involving browser automation or extensions.
* **Key Questions:** Can headless browsers be used to extract live chat data? Are there existing browser extensions? What are the resource requirements and reliability?
3. **Retrieve and Display Messages:** `main.py` will continuously check the shared queue for new messages from the webhook server and display them using `rich` styling.
* **Action:** Implement a loop in `main()` to `queue.get_nowait()` messages and `console.print()` them.
### **5. Advanced Quota Management & Optimization**
4. **Maintain Terminal Display:** Ensure `rich` styling (colors, alternating backgrounds) is applied to webhook-received messages.
* **Action:** Adapt existing `rich` styling logic for new message source.
* **Focus:** Strategies to minimize quota usage within a polling model, if no event-driven solution is found.
* **Key Questions:** What API parameters can reduce quota cost? Can intelligent polling be implemented? Are there any caching strategies?
### Phase 3: Third-Party Service Configuration (Manual Steps)
---
1. **Choose a Service:** Select a streaming service that provides webhook functionality (e.g., StreamElements, Streamlabs).
* **Action:** User to sign up/log in to chosen service.
**Prioritization:** All research will prioritize **open-source and Linux-compatible solutions**.
2. **Link YouTube Channel:** Connect your YouTube channel to the chosen service.
* **Action:** User to follow service-specific instructions.
3. **Configure Webhook:** Find the webhook settings within the service's dashboard.
* **Action:** User to configure a webhook to send POST requests on new chat messages.
4. **Expose Local Server (ngrok):** Since webhook services need a public URL, you'll likely need a tunneling service like `ngrok` during development.
* **Action:** User to install `ngrok` and run `ngrok http 5000` (if Flask runs on port 5000). Use the provided public `https` URL in the webhook configuration.
5. **Test:** Send a message in your YouTube live chat and verify it appears in your terminal via the webhook.
**Next Steps:** The findings from this research will be compiled into a structured document and utilized by a separate AI product to inform the design and implementation of a robust YouTube Live Chat monitoring solution.
## Dependencies
* `Flask`
* `rich`
* `ngrok` (for development/testing with public webhooks)
* `Flask` (for potential webhook server research)
* `rich` (for terminal display research)
* `ngrok` (for local webhook testing research)
## Future Enhancements
* Interactive message sending via webhook (if supported by the third-party service).
* More advanced terminal UI (e.g., `prompt_toolkit` for input).
* Web overlay integration.
* Web overlay integration.