YouTube.js

https://ytjs.dev/guide/
Admin
YouTube.js is a JavaScript client for YouTube's private API, InnerTube, enabling programmatic...
Tokens:2,572
Snippets:36
Trust Score:6.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install YouTube.js

Source: https://ytjs.dev/guide/getting-started.html

Commands to install the library using various package managers or Deno.

```bash
# NPM
npm install youtubei.js@latest

# Yarn
yarn add youtubei.js@latest

# Git (edge version)
npm install github:LuanRT/YouTube.js

# Deno
deno add npm:youtubei.js@latest
```

--------------------------------

### Initialize Innertube

Source: https://ytjs.dev/guide/getting-started.html

Basic setup to create an Innertube instance.

```typescript
import { Innertube } from 'youtubei.js';
const innertube = await Innertube.create(/* options */);
```

--------------------------------

### Import YouTube.js for Deno

Source: https://ytjs.dev/guide/getting-started.html

Import statement for the deprecated Deno-specific entry point.

```typescript
import { Innertube } from 'https://deno.land/x/youtubei/deno.ts';
```

--------------------------------

### Stream videos using dash.js

Source: https://ytjs.dev/guide/browser-usage.html

Convert video info into an MPEG-DASH manifest and play it using dash.js. URL transformation is necessary to ensure proxied requests work within the manifest.

```typescript
import { Innertube } from 'youtubei.js/web';
import dashjs from 'dashjs';

const innertube = await Innertube.create({ /* setup - see above */ });

// Get the video info
const videoInfo = await innertube.getInfo('videoId', { client: 'TV' });

// now convert to a dash manifest
// again - to be able to stream the video in the browser - you must proxy the requests through your own server
// to do this, we provide a method to transform the URLs before writing them to the manifest
const manifest = await videoInfo.toDash(url => {
  // modify the url
  // and return it
  return url;
});

const uri = "data:application/dash+xml;charset=utf-8;base64," + btoa(manifest);

const videoElement = document.getElementById('video_player');

const player = dashjs.MediaPlayer().create();
player.initialize(videoElement, uri, true);
```

--------------------------------

### Initialize a persistent cache

Source: https://ytjs.dev/guide/caching.html

Enables persistent caching by providing a directory path where session data will be stored.

```javascript
const innertube = await Innertube.create({
  cache: new UniversalCache(
    // Enables persistent caching
    true, 
    // Path to the cache directory. The directory will be created if it doesn't exist
    './.cache' 
  )
});
```

--------------------------------

### Retrieve video info using Actions

Source: https://ytjs.dev/guide/advanced-usage

Demonstrates how to manually execute an InnerTube request using the Actions class to retrieve video information.

```typescript
import { Innertube, UniversalCache } from 'youtubei.js';

const yt = await Innertube.create({ cache: new UniversalCache(true) });

async function getVideoInfo(videoId: string) {
  const videoInfo = await yt.actions.execute('/player', {
    // You can add any additional payloads here, and they'll merge with the default payload sent to InnerTube.
    videoId,
    client: 'YTMUSIC', // InnerTube client to use.
    parse: true // tells YouTube.js to parse the response (not sent to InnerTube).
  });

  return videoInfo;
}

const videoInfo = await getVideoInfo('jLTOuvBTLxA');
console.info(videoInfo);
```

--------------------------------

### Execute navigation endpoints

Source: https://ytjs.dev/guide/advanced-usage

Shows how to trigger a navigation endpoint from a parsed UI element like a button.

```typescript
import { Innertube, UniversalCache, YTNodes } from 'youtubei.js';

const yt = await Innertube.create({ cache: new UniversalCache(true) });

const artist = await yt.music.getArtist('UC52ZqHVQz5OoGhvbWiRal6g');
const albums = artist.sections[1].as(YTNodes.MusicCarouselShelf);

// Let's imagine that we wish to click on the “More” button:
const button = albums.as(YTNodes.MusicCarouselShelf).header?.more_content;

if (button) {
  // Having ensured that it exists, we can then call its navigation endpoint using the following code:
  const page = await button.endpoint.call(yt.actions, { parse: true });
  console.info(page);
}
```

--------------------------------

### Authenticate with Cookies

Source: https://ytjs.dev/guide/authentication

Recommended method for most web-based client types using a cookie string.

```javascript
const innertube = await Innertube.create({
  cookie: '...'
});
```

--------------------------------

### Configure custom fetch implementation

Source: https://ytjs.dev/guide/proxies

Use the fetch option in Innertube.create to inject a custom request handler for proxying or request modification.

```typescript
// provide a fetch implementation
const yt = await Innertube.create({
  fetch: async (input: RequestInfo | URL, init?: RequestInit) => {
    // make the request with your own fetch implementation
    // and return the response
    return new Response(
      /* ... */
    );
  }
});
```

--------------------------------

### Initialize a non-persistent cache

Source: https://ytjs.dev/guide/caching.html

Creates an Innertube instance with caching disabled for session data.

```javascript
import { Innertube, UniversalCache } from 'youtubei.js';
const innertube = await Innertube.create({ cache: new UniversalCache(false) });
```

--------------------------------

### Provide a Custom JavaScript Interpreter

Source: https://ytjs.dev/guide/getting-started.html

Configure a custom evaluator for YouTube's obfuscated JavaScript code using the Function constructor.

```typescript
import { Innertube, Platform, Types } from 'youtubei.js/web';

Platform.shim.eval = async (data: Types.BuildScriptResult) => {
  return new Function(data.output)();;
};

const innertube = await Innertube.create(/* options */);
// ...
```

--------------------------------

### Authenticate with YouTube TV OAuth2

Source: https://ytjs.dev/guide/authentication

Handles OAuth2 flow for the TV Innertube client. Requires listening for auth events and calling signIn.

```javascript
innertube.session.on('auth-pending', (data) => {
  // data.verification_url contains the authorization URL.
  // data.user_code contains the code to enter on the website.
});

innertube.session.on('auth', ({ credentials }) => {
  // Do something with the credentials, eg; save them to a file.
  console.log('Sign in successful');
});

// Fired when the access token expires.
innertube.session.on('update-credentials', ({ credentials }) => { /** do something with the updated credentials. */ });
  
await innertube.session.signIn(/* credentials */);
```

--------------------------------

### Change Log Levels in YouTube.js

Source: https://ytjs.dev/guide/troubleshooting

Configures the library's logging output level. Use this to filter messages by severity.

```javascript
import { Log } from 'youtubei.js';
// Available levels: NONE, ERROR, WARNING, INFO, DEBUG
Log.setLevel(Log.Level.NONE);
```

--------------------------------

### Cache OAuth2 Credentials

Source: https://ytjs.dev/guide/authentication

Persists credentials to avoid repeating the sign-in flow. Not recommended due to potential security risks.

```javascript
// If you use this, the next call to signIn won't fire 'auth-pending', instead just 'auth'
await innertube.session.oauth.cacheCredentials();
```

--------------------------------

### Revoke Credentials

Source: https://ytjs.dev/guide/authentication

Methods to sign out of the current session or remove cached credentials.

```javascript
await innertube.session.signOut();

// if you don't want to sign out of the current session
// and only want to delete the cached credentials, use:
await innertube.session.oauth.removeCache();
```

--------------------------------

### Parse InnerTube responses

Source: https://ytjs.dev/guide/advanced-usage

Utilizes the Parser utility to convert raw JSON responses into strongly-typed YTNodes for easier data manipulation.

```typescript
// See ./examples/parser

import { Parser, YTNodes } from 'youtubei.js';
import { readFileSync } from 'fs';

// YouTube Music's artist page response
const data = readFileSync('./artist.json').toString();

const page = Parser.parseResponse(JSON.parse(data));

const header = page.header?.item().as(YTNodes.MusicImmersiveHeader, YTNodes.MusicVisualHeader);

console.info('Header:', header);

// The parser uses a proxy object to add type safety and utility methods for working with InnerTube's data arrays:
const tab = page.contents?.item().as(YTNodes.SingleColumnBrowseResults).tabs.firstOfType(YTNodes.Tab);

if (!tab)
  throw new Error('Target tab not found');

if (!tab.content)
  throw new Error('Target tab appears to be empty');
  
const sections = tab.content?.as(YTNodes.SectionList).contents.as(YTNodes.MusicCarouselShelf, YTNodes.MusicDescriptionShelf, YTNodes.MusicShelf);

console.info('Sections:', sections);
```
Tokens:
Raw