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 ## 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. The research will focus on the following key areas:
* **Action:** Install Flask: `pip install Flask`
2. **Create `webhook_server.py`:** This file will contain the Flask application. ### **1. YouTube Data API v3 - Deeper Dive**
* **Action:** Create `webhook_server.py` with a basic Flask app structure.
3. **Define Webhook Endpoint:** Implement a POST endpoint (e.g., `/chat-webhook`) that will receive JSON payloads from the third-party service. * **Focus:** Exhaustive search for official, quota-friendly API endpoints or features.
* **Action:** Add `@app.route('/chat-webhook', methods=['POST'])` to `webhook_server.py`. * **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). ### **2. Third-Party Webhook/Event-Driven Solutions**
* **Action:** Add logic to `handle_webhook()` to extract `username` and `message` from `request.json`.
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. * **Focus:** Identify and analyze third-party services that provide webhook notifications for YouTube Live Chat.
* **Action:** Implement a shared `queue.Queue` and add messages to it. * **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. ### **3. Unofficial/Scraping Methods**
* **Action:** Implement `run_flask_app()` function and start it in a `threading.Thread`.
### 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. ### **4. Client-Side/Browser-Based Solutions**
* **Action:** Remove all YouTube Data API polling logic (`fetch_live_chat_messages`, `get_live_chat_id`).
2. **Start Webhook Server:** `main.py` will initiate the `webhook_server.py` in a separate thread. * **Focus:** Explore methods involving browser automation or extensions.
* **Action:** Import `webhook_server` and start its Flask thread in `main()`. * **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. ### **5. Advanced Quota Management & Optimization**
* **Action:** Implement a loop in `main()` to `queue.get_nowait()` messages and `console.print()` them.
4. **Maintain Terminal Display:** Ensure `rich` styling (colors, alternating backgrounds) is applied to webhook-received messages. * **Focus:** Strategies to minimize quota usage within a polling model, if no event-driven solution is found.
* **Action:** Adapt existing `rich` styling logic for new message source. * **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). **Prioritization:** All research will prioritize **open-source and Linux-compatible solutions**.
* **Action:** User to sign up/log in to chosen service.
2. **Link YouTube Channel:** Connect your YouTube channel to the chosen service. **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.
* **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.
## Dependencies ## Dependencies
* `Flask`
* `rich` * `Flask` (for potential webhook server research)
* `ngrok` (for development/testing with public webhooks) * `rich` (for terminal display research)
* `ngrok` (for local webhook testing research)
## Future Enhancements ## Future Enhancements
* Interactive message sending via webhook (if supported by the third-party service). * Interactive message sending via webhook (if supported by the third-party service).
* More advanced terminal UI (e.g., `prompt_toolkit` for input). * More advanced terminal UI (e.g., `prompt_toolkit` for input).
* Web overlay integration. * Web overlay integration.