How to Integrate Replit with YouTube API

1import os
2from flask import Flask, request, jsonify
3from googleapiclient.discovery import build
4from googleapiclient.errors import HttpError
5
6app = Flask(__name__)
7
8YOUTUBE_API_KEY = os.environ["YOUTUBE_API_KEY"]
9
10# Build the YouTube API client
11youtube = build("youtube", "v3", developerKey=YOUTUBE_API_KEY)
12
13
14@app.route("/search")
15def search_videos():
16    """
17    Search YouTube videos. Costs 100 quota units per call.
18    Params: q (query), max_results, order (relevance/date/viewCount), type
19    """
20    query = request.args.get("q")
21    if not query:
22        return jsonify({"error": "q parameter required"}), 400
23
24    max_results = min(int(request.args.get("max_results", 10)), 50)
25    order = request.args.get("order", "relevance")  # relevance, date, viewCount, rating
26    result_type = request.args.get("type", "video")
27
28    try:
29        response = youtube.search().list(
30            part="snippet",
31            q=query,
32            maxResults=max_results,
33            order=order,
34            type=result_type
35        ).execute()
36
37        items = []
38        for item in response.get("items", []):
39            snippet = item.get("snippet", {})
40            video_id = item.get("id", {}).get("videoId", "")
41            items.append({
42                "videoId": video_id,
43                "title": snippet.get("title", ""),
44                "channelTitle": snippet.get("channelTitle", ""),
45                "publishedAt": snippet.get("publishedAt", ""),
46                "description": snippet.get("description", "")[:200],
47                "thumbnail": snippet.get("thumbnails", {}).get("medium", {}).get("url", "")
48            })
49        return jsonify({"totalResults": response.get("pageInfo", {}).get("totalResults", 0), "items": items})
50    except HttpError as e:
51        return jsonify({"error": str(e)}), e.resp.status
52
53
54@app.route("/videos")
55def get_video_details():
56    """
57    Get details for one or more video IDs. Costs 1 quota unit per video.
58    Params: ids (comma-separated video IDs)
59    """
60    ids = request.args.get("ids", "")
61    if not ids:
62        return jsonify({"error": "ids parameter required (comma-separated)"}), 400
63
64    try:
65        response = youtube.videos().list(
66            part="snippet,statistics,contentDetails",
67            id=ids
68        ).execute()
69
70        items = []
71        for item in response.get("items", []):
72            stats = item.get("statistics", {})
73            content = item.get("contentDetails", {})
74            snippet = item.get("snippet", {})
75            items.append({
76                "videoId": item["id"],
77                "title": snippet.get("title", ""),
78                "channelTitle": snippet.get("channelTitle", ""),
79                "publishedAt": snippet.get("publishedAt", ""),
80                "duration": content.get("duration", ""),
81                "viewCount": stats.get("viewCount", "0"),
82                "likeCount": stats.get("likeCount", "0"),
83                "commentCount": stats.get("commentCount", "0")
84            })
85        return jsonify({"items": items})
86    except HttpError as e:
87        return jsonify({"error": str(e)}), e.resp.status
88
89
90@app.route("/channel")
91def get_channel():
92    """
93    Get channel details by ID or username.
94    Params: id (channel ID) or username
95    """
96    channel_id = request.args.get("id")
97    username = request.args.get("username")
98
99    if not channel_id and not username:
100        return jsonify({"error": "id or username parameter required"}), 400
101
102    try:
103        params = {
104            "part": "snippet,statistics,contentDetails"
105        }
106        if channel_id:
107            params["id"] = channel_id
108        else:
109            params["forUsername"] = username
110
111        response = youtube.channels().list(**params).execute()
112        return jsonify(response.get("items", []))
113    except HttpError as e:
114        return jsonify({"error": str(e)}), e.resp.status
115
116
117@app.route("/playlist")
118def get_playlist_items():
119    """
120    Get videos in a playlist.
121    Params: playlist_id, max_results
122    """
123    playlist_id = request.args.get("playlist_id")
124    if not playlist_id:
125        return jsonify({"error": "playlist_id parameter required"}), 400
126
127    max_results = min(int(request.args.get("max_results", 20)), 50)
128    try:
129        response = youtube.playlistItems().list(
130            part="snippet,contentDetails",
131            playlistId=playlist_id,
132            maxResults=max_results
133        ).execute()
134        return jsonify(response.get("items", []))
135    except HttpError as e:
136        return jsonify({"error": str(e)}), e.resp.status
137
138
139if __name__ == "__main__":
140    app.run(host="0.0.0.0", port=3000, debug=True)

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const YOUTUBE_API_KEY = process.env.YOUTUBE_API_KEY;
8const BASE_URL = 'https://www.googleapis.com/youtube/v3';
9
10async function ytGet(endpoint, params = {}) {
11  const { data } = await axios.get(`${BASE_URL}/${endpoint}`, {
12    params: { ...params, key: YOUTUBE_API_KEY }
13  });
14  return data;
15}
16
17// Search videos — 100 quota units per call
18app.get('/search', async (req, res) => {
19  const { q, max_results = 10, order = 'relevance', type = 'video' } = req.query;
20  if (!q) return res.status(400).json({ error: 'q parameter required' });
21  try {
22    const data = await ytGet('search', {
23      part: 'snippet',
24      q,
25      maxResults: Math.min(Number(max_results), 50),
26      order,
27      type
28    });
29    const items = data.items.map(item => ({
30      videoId: item.id?.videoId || '',
31      title: item.snippet?.title || '',
32      channelTitle: item.snippet?.channelTitle || '',
33      publishedAt: item.snippet?.publishedAt || '',
34      description: (item.snippet?.description || '').substring(0, 200),
35      thumbnail: item.snippet?.thumbnails?.medium?.url || ''
36    }));
37    res.json({ totalResults: data.pageInfo?.totalResults || 0, items });
38  } catch (err) {
39    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
40  }
41});
42
43// Get video statistics — 1 quota unit for all IDs
44app.get('/videos', async (req, res) => {
45  const { ids } = req.query;
46  if (!ids) return res.status(400).json({ error: 'ids parameter required (comma-separated)' });
47  try {
48    const data = await ytGet('videos', {
49      part: 'snippet,statistics,contentDetails',
50      id: ids
51    });
52    const items = data.items.map(item => ({
53      videoId: item.id,
54      title: item.snippet?.title || '',
55      channelTitle: item.snippet?.channelTitle || '',
56      duration: item.contentDetails?.duration || '',
57      viewCount: item.statistics?.viewCount || '0',
58      likeCount: item.statistics?.likeCount || '0',
59      commentCount: item.statistics?.commentCount || '0'
60    }));
61    res.json({ items });
62  } catch (err) {
63    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
64  }
65});
66
67// Get channel info
68app.get('/channel', async (req, res) => {
69  const { id, username } = req.query;
70  if (!id && !username) return res.status(400).json({ error: 'id or username required' });
71  const params = { part: 'snippet,statistics,contentDetails' };
72  if (id) params.id = id;
73  else params.forUsername = username;
74  try {
75    const data = await ytGet('channels', params);
76    res.json(data.items || []);
77  } catch (err) {
78    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
79  }
80});
81
82// Trending videos by country
83app.get('/trending', async (req, res) => {
84  const { country = 'US', max_results = 10, category_id = '0' } = req.query;
85  try {
86    const data = await ytGet('videos', {
87      part: 'snippet,statistics',
88      chart: 'mostPopular',
89      regionCode: country,
90      videoCategoryId: category_id,
91      maxResults: Math.min(Number(max_results), 50)
92    });
93    res.json(data.items || []);
94  } catch (err) {
95    res.status(err.response?.status || 500).json({ error: err.response?.data || err.message });
96  }
97});
98
99app.listen(3000, '0.0.0.0', () => {
100  console.log('YouTube API integration server running on port 3000');
101});

1[[ports]]
2internalPort = 3000
3externalPort = 80
4
5[deployment]
6run = ["node", "server.js"]
7deploymentTarget = "cloudrun"