How to Build a YouTube Upload Bot with Node.js and OAuth2

GOOGLE_CLIENT_ID=YOUR_CLIENT_ID_HERE
GOOGLE_CLIENT_SECRET=YOUR_CLIENT_SECRET_HERE
REDIRECT_URI=http://localhost:3000/oauth2callback
YOUTUBE_CHANNEL_ID=UCXXXXXXXXXXXXXXXXXX
NODE_ENV=production

npm init -y
npm install googleapis dotenv express axios path os stream

const { google } = require('googleapis');
const fs = require('fs');
require('dotenv').config();

const oauth2Client = new google.auth.OAuth2(
  process.env.GOOGLE_CLIENT_ID,
  process.env.GOOGLE_CLIENT_SECRET,
  process.env.REDIRECT_URI
);

function getAuthUrl() {
  const scopes = ['https://www.googleapis.com/auth/youtube.upload'];

  const url = oauth2Client.generateAuthUrl({
    access_type: 'offline',
    scope: scopes,
    prompt: 'consent'
  });

  return url;
}

function saveRefreshToken(tokens) {
  const tokenPath = 'tokens.json';
  fs.writeFileSync(tokenPath, JSON.stringify(tokens, null, 2));
  console.log(`Refresh token saved to ${tokenPath}`);
}

function loadRefreshToken() {
  const tokenPath = 'tokens.json';
  if (fs.existsSync(tokenPath)) {
    const tokens = JSON.parse(fs.readFileSync(tokenPath, 'utf8'));
    oauth2Client.setCredentials(tokens);
    return tokens;
  }
  return null;
}

async function exchangeCodeForToken(code) {
  try {
    const { tokens } = await oauth2Client.getToken(code);
    saveRefreshToken(tokens);
    oauth2Client.setCredentials(tokens);
    return tokens;
  } catch (error) {
    console.error('Error exchanging code for token:', error.message);
    throw error;
  }
}

async function getAccessToken() {
  const tokens = loadRefreshToken();

  if (!tokens) {
    throw new Error('No refresh token found. Run initial authentication first.');
  }

  oauth2Client.setCredentials(tokens);

  if (oauth2Client.isTokenExpiring()) {
    console.log('Token expiring, refreshing...');
    const { credentials } = await oauth2Client.refreshAccessToken();
    saveRefreshToken(credentials);
    oauth2Client.setCredentials(credentials);
    return credentials.access_token;
  }

  return tokens.access_token;
}

module.exports = {
  oauth2Client,
  getAuthUrl,
  exchangeCodeForToken,
  getAccessToken,
  loadRefreshToken,
  saveRefreshToken
};

const express = require('express');
const { getAuthUrl, exchangeCodeForToken, loadRefreshToken } = require('./auth');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3000;

app.get('/auth', (req, res) => {
  const authUrl = getAuthUrl();
  res.redirect(authUrl);
});

app.get('/oauth2callback', async (req, res) => {
  const code = req.query.code;

  if (!code) {
    return res.status(400).send('No authorization code received');
  }

  try {
    const tokens = await exchangeCodeForToken(code);
    res.send('Authorization successful! You can close this window and run your upload script.');
  } catch (error) {
    console.error('OAuth error:', error.message);
    res.status(500).send('Authorization failed: ' + error.message);
  }
});

app.get('/health', (req, res) => {
  const tokens = loadRefreshToken();
  if (tokens) {
    res.json({ status: 'authenticated', channelId: process.env.YOUTUBE_CHANNEL_ID });
  } else {
    res.json({ status: 'not_authenticated', authUrl: 'http://localhost:3000/auth' });
  }
});

app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
  console.log(`Visit http://localhost:${PORT}/auth to authenticate`);
});

const fs = require('fs');
const { oauth2Client } = require('./auth');
require('dotenv').config();

const TOKEN_FILE = 'tokens.json';
const TOKEN_REFRESH_THRESHOLD = 300; // Refresh if expiring in next 5 minutes

class TokenManager {
  constructor() {
    this.tokens = this.loadTokens();
  }

  loadTokens() {
    if (fs.existsSync(TOKEN_FILE)) {
      return JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'));
    }
    return null;
  }

  saveTokens(tokens) {
    fs.writeFileSync(TOKEN_FILE, JSON.stringify(tokens, null, 2));
    this.tokens = tokens;
  }

  isExpiringSoon() {
    if (!this.tokens || !this.tokens.expiry_date) {
      return true;
    }
    const now = Date.now();
    const expiryTime = this.tokens.expiry_date;
    return (expiryTime - now) < (TOKEN_REFRESH_THRESHOLD * 1000);
  }

  async getValidAccessToken() {
    if (!this.tokens) {
      throw new Error('No tokens found. Authenticate first.');
    }

    oauth2Client.setCredentials(this.tokens);

    if (this.isExpiringSoon()) {
      console.log(`[${new Date().toISOString()}] Token expiring soon, refreshing...`);
      try {
        const { credentials } = await oauth2Client.refreshAccessToken();
        this.saveTokens(credentials);
        oauth2Client.setCredentials(credentials);
        console.log(`[${new Date().toISOString()}] Token refreshed successfully`);
        return credentials.access_token;
      } catch (error) {
        console.error('Token refresh failed:', error.message);
        throw error;
      }
    }

    return this.tokens.access_token;
  }
}

module.exports = new TokenManager();

const { google } = require('googleapis');
const fs = require('fs');
const path = require('path');
const tokenManager = require('./tokenManager');
const { oauth2Client } = require('./auth');
require('dotenv').config();

const youtube = google.youtube('v3');

async function uploadVideo(videoFilePath, metadata) {
  try {
    const accessToken = await tokenManager.getValidAccessToken();
    oauth2Client.setCredentials({ access_token: accessToken });

    const fileName = path.basename(videoFilePath);
    const fileSize = fs.statSync(videoFilePath).size;

    console.log(`[${new Date().toISOString()}] Starting upload: ${fileName} (${fileSize} bytes)`);

    const response = await youtube.videos.insert(
      {
        part: 'snippet,status,processingDetails',
        requestBody: {
          snippet: {
            title: metadata.title || 'Untitled Video',
            description: metadata.description || '',
            tags: metadata.tags || [],
            categoryId: metadata.categoryId || '22',
            defaultLanguage: metadata.defaultLanguage || 'en',
            defaultAudioLanguage: metadata.defaultAudioLanguage || 'en'
          },
          status: {
            privacyStatus: metadata.privacyStatus || 'private',
            publishAt: metadata.publishAt || null,
            selfDeclaredMadeForKids: metadata.madeForKids || false
          }