import { get_song, search } from "https://deno.land/x/muse@VERSION/mod.ts";

// you can also use the latest version (not recommended) with
// import { get_song, search } from "https://deno.land/x/muse/mod.ts";

// you can also import directly from github
// import { get_song, search } from "https://raw.githubusercontent.com/vixalien/muse/VERSION/mod.ts";

search("drake")
  .then((data) => {
    console.log("search results", data);
  });

get_song("dQw4w9WgXcQ")
  .then((data) => {
    console.log("song", data);
  });

Browser

You'll need to use a CDN that supports ES modules, such as esm.sh, jspm.io or skypack.dev.

You'll also need to use a proxy server to get around CORS errors. It's a good idea to self host the proxy server (cors-anywhere and deno_deploy_cors_proxy are good options).

import { search, set_option } from "https://esm.sh/libmuse@VERSION";

// import { search, set_option } from "https://jspm.dev/npm:libmuse@VERSION";
// import { search, set_option } from "https://cdn.skypack.dev/libmuse@VERSION";

set_option("proxy", "https://proxy.example.com/");

search("top radio")
  .then((data) => {
    console.log("search results", data);
  });

Node

First install using your preferred package manager (npm, yarn, pnpm etc.)

npm install libmuse

Then use it in by importing libmuse. The Node version has the exact same features as the Deno version.

import { get_song, search } from "libmuse";
// commonjs: const { get_artist } = require("libmuse");

get_artist("UCvyjk7zKlaFyNIPZ-Pyvkng")
  .then((data) => {
    console.log("artist", data);
  });

For the complete list of operations, see the docs.

Auth

Currently, muse supports oauth authentication by posing as the YouTube TV app.

Here's the flow:

Get a login code
Go to the given login url, and type in the login code on a device that is logged into a google account
Get the OAuth token & refresh tokens

import { get_option, setup } from "https://deno.land/x/muse@VERSION/mod.ts";

/*
node imports:

import { get_option, setup } from "libmuse";

commonjs imports:

const { get_option, setup } = require("libmuse");
*/

const auth = get_option("auth");

setup({
  // make sure to persist the token
  store: new DenoFileStore("store/muse-store.json"),
  debug: true,
});

// this is the authentication flow
const auth_flow = async () => {
  if (auth.has_token()) return;
  console.log("Getting login code...");

  const loginCode = await auth.get_login_code();

  console.log(
    `Go to ${loginCode.verification_url} and enter the code: ${loginCode.user_code}`,
  );

  // not necessary, but saves some requests
  confirm("Press enter when you have logged in");

  console.log("Loading token...");

  await auth.load_token_with_code(
    loginCode.device_code,
    loginCode.interval,
  );

  console.log("Logged in!", auth._token);
};

// listen to the `requires-login` event, then resolve pass on a function that
// returns a promise that will resolve when the auth flow is complete
auth.addEventListener("requires-login", (event) => {
  const resolve = event.detail;

  resolve(auth_flow);
});

In the future, I plan to add support for other auth methods, such as cookies and Youtube TV login codes.

Storage

You can pass in a storage object to the client to persist the auth token.

import { setup } from "https://deno.land/x/muse@VERSION/mod.ts";
import {
  DenoFileStore,
  get_default_store,
  LocalStorageStore,
  MemoryStore,
  Store,
} from "https://deno.land/x/muse@VERSION/store.ts";

/*
npm imports:

import { setup } from "libmuse";
import {
  DenoFileStore,
  get_default_store,
  LocalStorageStore,
  MemoryStore,
  Store,
} from "libmuse/store.js";

commonjs imports:

const { setup } = require("libmuse");
const {
  DenoFileStore,
  get_default_store,
  LocalStorageStore,
  MemoryStore,
  Store,
} = require("libmuse/store.js");
*/

// you can use the default store, which is DenoFileStore if available, then LocalStorageStore, then MemoryStore
const client = setup({ store: get_default_store() });

// or you can use any of the built-in stores
const client = setup({ store: new DenoFileStore("/path/to/file.json") });
const client = setup({ store: new LocalStorageStore() });
const client = setup({ store: new MemoryStore() });

// or you can implement your own store
// by extending the Store abstract class
class MyStore extends Store {
  get<T>(key: string): T | null;
  set(key: string, value: unknown): void;
  delete(key: string): void;
}

// then use it accordingly
const client = setup({ store: new MyStore() });

// Do note that setup() can be called multiple times, but it's not recommended. 
// this is because setup overrides the global store, so if you call setup()
// multiple times, other options set before will be ignored. example:

setup({ auth: { /* custom auth options */ } });
setup({ store: /* custom store */ });

// the above will only use the custom store, and ignore the custom auth options

Operations

I'm currently targetting to match the ytmusicapi's capabilities.

search

search
search suggestions

browsing

explore

watch

get queue ~~get watch playlist~~

library

playlists

uploads

get library uploads
get library upload songs
get library upload artists
get library upload albums
get library upload artist
get library upload album
upload song (doesn't currectly work because the TV client can't do uploads)
delete upload entity

Acknowledgements

ytmusicapi - The inspiration for this library
Youtube Internal Clients - The source of the client names and versions
many random gists and blog posts whose links I've lost

FAQs

What is libmuse?

Is libmuse well maintained?

Package last updated on 09 Jun 2023

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

libmuse

muse

Usage

Deno