Labs.fm

Build with Labs.fm

Welcome to the Labs.fm developer hub. Here you can find all of the information you need to start developing your own products and services on top of Labs.fm technology. And we're always on hand to help out if you get stuck. So, what are you waiting for?

Get Started

/health

Check that the API is responding

 
gethttps://api.labs.fm/health
curl --request GET \
  --url https://api.labs.fm/health
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/health' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/health")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/health");

xhr.send(data);
import requests

url = "https://api.labs.fm/health"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 

The intention of the /health endpoint is to provide an unauthenticated, responsive way to ensure that the API is responding as it should, for use in systems monitoring and alerting applications, such as StatusPage or Pingdom.

It should always return a 200 status code.

/artists

List popular Artists

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists
curl --request GET \
  --url https://api.labs.fm/artists
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/artists' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

country
string

Filter the artists to those from an individual country, with an official 2-letter country code (eg 'US')

gender
string

Filter the artists to those of a particular gender - either 'male' or 'female'

 

In order to limit the number of results returned, only Artists with a current popularity score of greater than zero are available at this endpoint.

/artists/search

Find matching Artists for a text query

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/search
curl --request GET \
  --url 'https://api.labs.fm/artists/search?q=q'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/search',
  qs: { q: 'q' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/search?q=q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/search?q=q");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/search"

querystring = {"q":"q"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

q
string
required

Search query string

 

Search is implemented using a matching algorithm that attempts to account for typos and spelling, and return the closest possible matches.

The result is a paginated list of Artists, ordered in descending order of the closest match.

/artists/{id}

Display an individual Artist's metadata

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/id
curl --request GET \
  --url https://api.labs.fm/artists/id
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/id");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
    "id": "b45bf0cf-f7a9-42d1-a20b-0322856b7420",
    "name": "Taylor Swift",
    "type": "person",
    "gender": "female",
    "country": "US",
    "popularity": 88,
    "images": [
        {
            "width": 665,
            "height": 665,
            "url": "http://images.recast.fm/artists/b45bf0cf-f7a9-42d1-a20b-0322856b7420/665x665.jpg"
        },
        {
            "width": 665,
            "height": 665,
            "url": "http://images.recast.fm/artists/b45bf0cf-f7a9-42d1-a20b-0322856b7420/665x665.jpg"
        },
        {
            "width": 983,
            "height": 983,
            "url": "http://images.recast.fm/artists/b45bf0cf-f7a9-42d1-a20b-0322856b7420/983x983.jpg"
        }
    ],
    "external_ids": {
        "allmusic": "mn0000472102",
        "apple": 159260351,
        "bbc": "20244d07-534f-4eff-b4d4-930878889970",
        "deezer": 12246,
        "discogs": 1124645,
        "facebook": "TaylorSwift",
        "genius": 1177,
        "google": "A4saifqiazru565jhrrm6d72jaa",
        "imdb": "nm2357847",
        "instagram": "taylorswift",
        "joox": 11921,
        "last.fm": "Taylor+Swift",
        "musicbrainz": "20244d07-534f-4eff-b4d4-930878889970",
        "songkick": 217815,
        "spotify": "06HL4z0CvFAxyc27GXpf02",
        "twitter": "taylorswift13",
        "youtube": "UCqECaJ8Gagnn7YCbPEzWH6g"
    },
    "external_urls": {
        "allmusic": "http://www.allmusic.com/artist/mn0000472102",
        "apple": "https://itunes.apple.com/us/artist/taylor-swift/159260351?uo=4",
        "bbc": "http://www.bbc.co.uk/music/artists/20244d07-534f-4eff-b4d4-930878889970",
        "deezer": "https://www.deezer.com/artist/12246",
        "discogs": "https://www.discogs.com/artist/1124645",
        "facebook": "https://www.facebook.com/TaylorSwift",
        "genius": "https://genius.com/artists/Taylor-swift",
        "google": "https://play.google.com/store/music/artist/Taylor_Swift?id=A4saifqiazru565jhrrm6d72jaa",
        "imdb": "http://www.imdb.com/name/nm2357847/",
        "instagram": "http://instagram.com/taylorswift/",
        "last.fm": "http://www.last.fm/music/Taylor+Swift",
        "musicbrainz": "https://musicbrainz.org/artist/20244d07-534f-4eff-b4d4-930878889970",
        "official": "http://www.bigmachinelabelgroup.com/artist/taylor-swift/",
        "songkick": "http://www.songkick.com/artists/217815-taylor-swift?utm_source=40182&utm_medium=partner",
        "spotify": "https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02",
        "twitter": "https://twitter.com/taylorswift13",
        "wikipedia": "https://en.wikipedia.org/wiki/Taylor_Swift",
        "youtube": "https://www.youtube.com/channel/UCqECaJ8Gagnn7YCbPEzWH6g"
    }
}

Path Params

id
string
required
 

/artists/{service}:{id}

Display an individual Artists's metadata by referencing a third-party unique identifier

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/service:id
curl --request GET \
  --url https://api.labs.fm/artists/spotify:id
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/spotify:id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/spotify:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/spotify:id");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/spotify:id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

service
string
required

Lower-case service name. Supported services can be discovered in the track external_ids information.

id
string
required

The unique identifier for the Artist in the third-party service

 

This track reference method can also be used to access all endpoints nested below the /artists/{id} endpoint, by replacing the {id} format with the {service}:{id} reference format.

Custom catalogue integrations

For Enterprise customers, we are able to integrate your existing catalogue so that you can make reference to artists using your internal identifiers, allowing seamless integration of your catalogue, and Labs.fm API functionality. Contact us about this service.

/artists/{id}/collaborations

List other Artists that an individual Artist has collaborated with

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/id/collaborations
curl --request GET \
  --url https://api.labs.fm/artists/id/collaborations
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/id/collaborations' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id/collaborations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/id/collaborations");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id/collaborations"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string

Filter the artists to those from an individual country, with an official 2-letter country code (eg 'US')

gender
string

Filter the artists to those of a particular gender - either 'male' or 'female'

 

/artists/{id}/followings

Return follower counts for an individual Artist on third party services

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/id/followings
curl --request GET \
  --url https://api.labs.fm/artists/id/followings
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/id/followings' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id/followings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/id/followings");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id/followings"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

This endpoint returns the follower counts for the Artist on third-party services, including social media and streaming services.

If there are limited services available for a particular Artist, it is likely that the Artist needs links to the third-party services to be added to their profile. This can be achieved by requesting a manual research of the Artist via the /artists/{id}/research endpoint.

/artists/{id}/tracks

List Tracks on which an Artist has performed

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/id/tracks
curl --request GET \
  --url https://api.labs.fm/artists/id/tracks
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/id/tracks' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id/tracks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/id/tracks");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id/tracks"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

role
string
released
date

Filter the Tracks to those which have been released since a supplied date

 

Tracks returned by this endpoint are ordered by current popularity, from most popular to the least popular

/artists/{id}/stations

List Stations on which an Artist is currently playlisted

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/id/stations
curl --request GET \
  --url https://api.labs.fm/artists/id/stations
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/id/stations' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id/stations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/id/stations");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id/stations"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string
now
boolean

Set to true to limit the stations to those busy playing the track

 

Stations returned by this endpoint are ordered by play count over the previous 7 day period, from the most played to the least played

/artists/{id}/playlists

List all current Playlist positions for an individual Artist, including position history

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/id/playlists
curl --request GET \
  --url https://api.labs.fm/artists/id/playlists
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/id/playlists' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id/playlists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/id/playlists");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id/playlists"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

Playlists returned by this endpoint are ordered by the position of the artist in the playlist, from the highest position (1) to last position.

/artists/{id}/charts

List all current Chart positions for an individual Artist, including position history

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/id/charts
curl --request GET \
  --url https://api.labs.fm/artists/id/charts
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/id/charts' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id/charts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/id/charts");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id/charts"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

Charts returned by this endpoint are ordered by the position of the artist in the chart, from the highest position (1) to the last position.

/artists/{id}/labels

List Labels that an individual Artist has released under

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/id/labels
curl --request GET \
  --url https://api.labs.fm/artists/id/labels
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/id/labels' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id/labels")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/id/labels");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id/labels"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

Labels returned by this endpoint are ordered by date of release by the artist under the label, from the most recent to the least recent.

/artists/{id}/popularity

Displays the popularity history for an individual Artist

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/id/popularity
curl --request GET \
  --url https://api.labs.fm/artists/id/popularity
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/id/popularity' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id/popularity")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/id/popularity");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id/popularity"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string

Calculate the popularity for an individual country. Can be used in combination with source below.

source
string

To return a popularity score that combines all sources, omit this parameter

 

See Popularity for further information about this proprietary Labs.fm metric.

/artists/{id}/related

List Artists that are related to an individual Artist

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/artists/id/related
curl --request GET \
  --url https://api.labs.fm/artists/id/related
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/artists/id/related' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id/related")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/artists/id/related");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id/related"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string

Filter the artists to those from an individual country, with an official 2-letter country code (eg 'US')

gender
string

Filter the artists to those of a particular gender - either 'male' or 'female'

 

Related Artists are based on a machine-learning recommendation engine which relates Artists based on their characteristics, as well as any associations between them, such as collaborations and listening overlap. For this reason, results are related but not necessarily similar acoustically.

/artists/{id}/research

Manually research information about an individual Artist

 

Query Auth

 Authentication is required for this endpoint.
posthttps://api.labs.fm/artists/id/research
curl --request POST \
  --url https://api.labs.fm/artists/id/research
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.labs.fm/artists/id/research' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/artists/id/research")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.labs.fm/artists/id/research");

xhr.send(data);
import requests

url = "https://api.labs.fm/artists/id/research"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

callback
string

Callback URL where updated Artist information should be POSTed to on completion

 

There may be cases where there is limited available information about an individual Artist, and other information - such as external IDs or biographical data - may be lacking. In these cases, you can programmatically request that this Artist is manually researched by our team, and the information for this Artist updated as soon as this process is complete.

Depending on the workload, this can take up to 3 days to complete. It is possible to supply a callback URL where this updated Artist object will be POSTed on completion.

/charts

List all Charts that an API account has access to

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/charts
curl --request GET \
  --url https://api.labs.fm/charts
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/charts' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/charts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/charts");

xhr.send(data);
import requests

url = "https://api.labs.fm/charts"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

country
string

Filter the charts to those from an individual country, with an official 2-letter country code (eg ‘US’)

 

/charts/search

Find matching Charts for a text query

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/charts/search
curl --request GET \
  --url https://api.labs.fm/charts/search
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/charts/search' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/charts/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/charts/search");

xhr.send(data);
import requests

url = "https://api.labs.fm/charts/search"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

q
string

Search query string

 

/charts/{id}

Display an individual Chart's metadata

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/charts/id
curl --request GET \
  --url https://api.labs.fm/charts/id
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/charts/id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/charts/id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/charts/id");

xhr.send(data);
import requests

url = "https://api.labs.fm/charts/id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

/charts/{id}/tracks

List all Tracks which are currently on an individual Chart

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/charts/id/tracks
curl --request GET \
  --url https://api.labs.fm/charts/id/tracks
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/charts/id/tracks' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/charts/id/tracks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/charts/id/tracks");

xhr.send(data);
import requests

url = "https://api.labs.fm/charts/id/tracks"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

released
date

Filter the Tracks to those which have been released since a supplied date

 

/charts/{id}/artists

List all Artists which are currently on an individual Chart

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/charts/id/artists
curl --request GET \
  --url https://api.labs.fm/charts/id/artists
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/charts/id/artists' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/charts/id/artists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/charts/id/artists");

xhr.send(data);
import requests

url = "https://api.labs.fm/charts/id/artists"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string

Filter the artists to those from an individual country, with an official 2-letter country code (eg 'US')

gender
string

Filter the artists to those of a particular gender - either 'male' or 'female'

 

/charts/{id}/positions

List the position of each entry in the current Chart, including position history

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/charts/id/positions
curl --request GET \
  --url https://api.labs.fm/charts/id/positions
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/charts/id/positions' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/charts/id/positions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/charts/id/positions");

xhr.send(data);
import requests

url = "https://api.labs.fm/charts/id/positions"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

This endpoint returns any items in the current Chart, their position, and any history of that item's position in the individual Chart. This allows for the calculation of position deltas, weeks on the chart, and related data.

Where information of this nature is available, metric values (such as 'plays', 'downloads', or 'sales') will be included in the position history.

Take note that Charts may support multiple item types. For example, some charts may list Tracks, while others may list Artists or Releases.

/curators

List all Curators that an API account has access to

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/curators
curl --request GET \
  --url https://api.labs.fm/curators
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/curators' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/curators")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/curators");

xhr.send(data);
import requests

url = "https://api.labs.fm/curators"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 

/curators/search

Find matching Curators for a text query

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/charts/search
curl --request GET \
  --url https://api.labs.fm/charts/search
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/charts/search' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/charts/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/charts/search");

xhr.send(data);
import requests

url = "https://api.labs.fm/charts/search"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

q
string

Search query string

 

/curators/{id}

Display an individual Curators's metadata

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/curators/id
curl --request GET \
  --url https://api.labs.fm/curators/id
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/curators/id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/curators/id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/curators/id");

xhr.send(data);
import requests

url = "https://api.labs.fm/curators/id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 

Note about Stations: in some cases, a Station will also curate and publish Playlists to third-party streaming services. In these cases, their Station ID also functions as a Curator ID, and can be used to access this and all nested endpoints.

/curators/{id}/playlists

List Playlists that belong to an individual Curator

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/curators/id/playlists
curl --request GET \
  --url https://api.labs.fm/curators/id/playlists
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/curators/id/playlists' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/curators/id/playlists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/curators/id/playlists");

xhr.send(data);
import requests

url = "https://api.labs.fm/curators/id/playlists"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 

Playlists returned by this endpoint are listed by order of following, from most to least popular, for services where this data is available, and falls back to alphabetical order when it is not.

/labels/search

Find matching Labels for a text query

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/labels/search
curl --request GET \
  --url 'https://api.labs.fm/labels/search?q=q'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/labels/search',
  qs: { q: 'q' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/labels/search?q=q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/labels/search?q=q");

xhr.send(data);
import requests

url = "https://api.labs.fm/labels/search"

querystring = {"q":"q"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

q
string
required

Search query string

 

/labels/{id}

Display an individual Label's metadata

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/labels/id
curl --request GET \
  --url https://api.labs.fm/labels/id
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/labels/id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/labels/id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/labels/id");

xhr.send(data);
import requests

url = "https://api.labs.fm/labels/id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

/labels/{id}/parents

List any Labels to which an individual Label belongs in the ownership/management hierarchy

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/labels/id/parents
curl --request GET \
  --url https://api.labs.fm/labels/id/parents
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/labels/id/parents' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/labels/id/parents")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/labels/id/parents");

xhr.send(data);
import requests

url = "https://api.labs.fm/labels/id/parents"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

One of the features of the Labs.fm API is that it gives you access to the full label hierarchy - that is, the ownership/management structures of larger labels.

This endpoint lists any labels that a label falls under.

/labels/{id}/children

List any Labels to that fall under an individual Label in the ownership/management hierarchy

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/labels/id/children
curl --request GET \
  --url https://api.labs.fm/labels/id/children
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/labels/id/children' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/labels/id/children")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/labels/id/children");

xhr.send(data);
import requests

url = "https://api.labs.fm/labels/id/children"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

/labels/{id}/tracks

List any Tracks released under an individual Label

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/labels/id/tracks
curl --request GET \
  --url https://api.labs.fm/labels/id/tracks
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/labels/id/tracks' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/labels/id/tracks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/labels/id/tracks");

xhr.send(data);
import requests

url = "https://api.labs.fm/labels/id/tracks"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

released
date

Filter the Tracks to those which have been released since a supplied date

 

/labels/{id}/artists

List any Artists released under an individual Label

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/labels/id/artists
curl --request GET \
  --url https://api.labs.fm/labels/id/artists
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/labels/id/artists' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/labels/id/artists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/labels/id/artists");

xhr.send(data);
import requests

url = "https://api.labs.fm/labels/id/artists"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string

Filter the artists to those from an individual country, with an official 2-letter country code (eg ‘US')

gender
string

Filter the artists to those of a particular gender - either 'male' or 'female'

 

/labels/{id}/releases

List any Releases (commonly referred to as 'albums') released under an individual Label

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/labels/id/releases
curl --request GET \
  --url https://api.labs.fm/labels/id/releases
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/labels/id/releases' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/labels/id/releases")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/labels/id/releases");

xhr.send(data);
import requests

url = "https://api.labs.fm/labels/id/releases"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

released
date

Filter the Releases to those which have been released since a supplied date

 

/playlists

List all Playlists that an API account has access to

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/playlists
curl --request GET \
  --url https://api.labs.fm/playlists
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/playlists' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/playlists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/playlists");

xhr.send(data);
import requests

url = "https://api.labs.fm/playlists"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 

/playlists/search

Find matching Playlists for a text query

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/playlists/search
curl --request GET \
  --url 'https://api.labs.fm/playlists/search?q=q'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/playlists/search',
  qs: { q: 'q' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/playlists/search?q=q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/playlists/search?q=q");

xhr.send(data);
import requests

url = "https://api.labs.fm/playlists/search"

querystring = {"q":"q"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

q
string
required

Search query string

 

/playlists/{id}

Display an individual Playlist's metadata

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/playlists/id
curl --request GET \
  --url https://api.labs.fm/playlists/id
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/playlists/id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/playlists/id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/playlists/id");

xhr.send(data);
import requests

url = "https://api.labs.fm/playlists/id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

/playlists/{id}/tracks

List all Tracks which are currently on an individual Playlist

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/playlists/id/tracks
curl --request GET \
  --url https://api.labs.fm/playlists/id/tracks
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/playlists/id/tracks' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/playlists/id/tracks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/playlists/id/tracks");

xhr.send(data);
import requests

url = "https://api.labs.fm/playlists/id/tracks"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

released
date

Filter the Tracks to those which have been released since a supplied date

 

/playlists/{id}/artists

List all Artists which are currently on an individual Playlist

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/playlists/id/artists
curl --request GET \
  --url https://api.labs.fm/playlists/id/artists
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/playlists/id/artists' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/playlists/id/artists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/playlists/id/artists");

xhr.send(data);
import requests

url = "https://api.labs.fm/playlists/id/artists"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string

Filter the artists to those from an individual country, with an official 2-letter country code (eg 'US')

gender
string

Filter the artists to those of a particular gender - either 'male' or 'female'

 

/playlists/{id}/positions

List the position of each entry in the current Playlist, including position history

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/playlists/id/positions
curl --request GET \
  --url https://api.labs.fm/playlists/id/positions
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/playlists/id/positions' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/playlists/id/positions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/playlists/id/positions");

xhr.send(data);
import requests

url = "https://api.labs.fm/playlists/id/positions"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

This endpoint returns any items in the current Playlist, their position, and any history of that item's position in the individual Playlist.

/playlists/{id}/profile

Display the acoustic profile of an individual Playlist

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/playlists/id/profile
curl --request GET \
  --url https://api.labs.fm/playlists/id/profile
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/playlists/id/profile' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/playlists/id/profile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/playlists/id/profile");

xhr.send(data);
import requests

url = "https://api.labs.fm/playlists/id/profile"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

The acoustic profile for an individual Playlist is calculated based on the Tracks that are currently listed on the playlist.

/stations

List all Stations that an API account has access to

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/stations
curl --request GET \
  --url https://api.labs.fm/stations
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/stations' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/stations");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 

/stations/search

Find matching Stations for a text query

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/stations/search
curl --request GET \
  --url 'https://api.labs.fm/stations/search?q=q'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/stations/search',
  qs: { q: 'q' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations/search?q=q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/stations/search?q=q");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations/search"

querystring = {"q":"q"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

q
string
required

Search query string

 

/stations/{id}

Display an individual Station's metadata

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/stations/id
curl --request GET \
  --url https://api.labs.fm/stations/id
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/stations/id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations/id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/stations/id");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations/id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

/stations/{id}/nowplaying

Display any currently-playing Track for a Station

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/stations/id/nowplaying
curl --request GET \
  --url https://api.labs.fm/stations/id/nowplaying
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/stations/id/nowplaying' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations/id/nowplaying")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/stations/id/nowplaying");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations/id/nowplaying"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

This endpoint returns a currently-playing Track for an individual Station, where this functionality is supported (for a full list of supported stations, contact us).

Where there is no currently-playing track, the response may be either a) a blank response, or b) a Track that has recently finished playing, depending on how recently any cache was expired.

Instead of polling this endpoint, Enterprise partners can subscribe to webhook updates.

Stations may integrate and access this endpoint for free. Contact us to take us up on this offer.

/stations/{id}/nowplaying/history

List recently-played Tracks for an individual Station

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/stations/id/nowplaying/history
curl --request GET \
  --url https://api.labs.fm/stations/id/nowplaying/history
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/stations/id/nowplaying/history' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations/id/nowplaying/history")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/stations/id/nowplaying/history");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations/id/nowplaying/history"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

Depending on the Station, these results may be slightly delayed. Contact us if you'd like further information about which Stations support completely realtime data.

Stations may integrate and access this endpoint for free. Contact us to take us up on this offer.

/stations/{id}/tracks

List all Tracks which are currently playlisted on an individual Station

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/stations/id/tracks
curl --request GET \
  --url https://api.labs.fm/stations/id/tracks
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/stations/id/tracks' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations/id/tracks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/stations/id/tracks");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations/id/tracks"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

released
date

Filter the Tracks to those which have been released since a supplied date

 

Station data is calculated on a rolling 7 day period. Tracks returned by this point have been played by the Station at least once since exactly 7 days ago.

Tracks returned by this endpoint are ordered by play count over the previous 7 day period, from the most played to the least played

/stations/{id}/artists

List all Artists which are currently playlisted on an individual Station

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/stations/id/artists
curl --request GET \
  --url https://api.labs.fm/stations/id/artists
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/stations/id/artists' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations/id/artists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/stations/id/artists");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations/id/artists"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string

Filter the artists to those from an individual country, with an official 2-letter country code (eg 'US')

gender
string

Filter the artists to those of a particular gender - either 'male' or 'female'

 

Station data is calculated on a rolling 7 day period. Artists returned by this point have been played by the Station at least once since exactly 7 days ago.

Artists returned by this endpoint are ordered by play count over the previous 7 day period, from the most played to the least played

/stations/{id}/related

List Stations that are related to an individual Stations

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/stations/id/related
curl --request GET \
  --url https://api.labs.fm/stations/id/related
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/stations/id/related' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations/id/related")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/stations/id/related");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations/id/related"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

Related Stations are based on a machine-learning recommendation engine which relates Stations based on how likely they are to playlist similar items.

Results are ordered from the most similar to the least similar.

/stations/{id}/profile

Display the acoustic profile of an individual Station

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/stations/id/profile
curl --request GET \
  --url https://api.labs.fm/stations/id/profile
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/stations/id/profile' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations/id/profile")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/stations/id/profile");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations/id/profile"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

The acoustic profile for an individual Station is calculated based on the Tracks that they have played on a rolling 7 day period, divided into hour of day (in UTC), accounting for how often each track has been played.

/stations/{id}/streams

List any known live audio streams for an individual Station

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/stations/id/streams
curl --request GET \
  --url https://api.labs.fm/stations/id/streams
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/stations/id/streams' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations/id/streams")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/stations/id/streams");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations/id/streams"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

/stations/{id}/playing

Update the currently-playing item for an individual Station

 

Query Auth

 Authentication is required for this endpoint.
posthttps://api.labs.fm/stations/id/playing
curl --request POST \
  --url https://api.labs.fm/stations/id/playing
var request = require("request");

var options = { method: 'POST',
  url: 'https://api.labs.fm/stations/id/playing' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/stations/id/playing")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.labs.fm/stations/id/playing");

xhr.send(data);
import requests

url = "https://api.labs.fm/stations/id/playing"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Body Params

type
string
required

One of: track, commercial, news, or live

id
string
required

The broadcaster's unique identifier for the item (for example, a cart number)

artist
string
title
string
required
timestamp
date-time
required

UTC timestamp of when the item started playing

duration
int32

Item duration, in seconds (where available)

skippable
boolean

This value is only relevant where the partner intends integrating the Recast interactive radio technology.

 

The /stations/{id}/playing endpoint allows partner broadcasters to directly post tracks from their own automation or queueing systems to the Labs.fm API.

Information should be POSTed to the endpoint as either a JSON object or as form-encoded parameters.

Stations may integrate and access this endpoint for free. Contact us to take us up on this offer.

/tracks

List most popular tracks

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks
curl --request GET \
  --url https://api.labs.fm/tracks
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/tracks' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

released
date

Filter the Tracks to those which have been released since a supplied date

 

In order to limit the number of results returned, only Tracks with a current popularity score of greater than zero are available at this endpoint.

/tracks/search

Find matching Tracks for a text query

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/search
curl --request GET \
  --url 'https://api.labs.fm/tracks/search?q=q'
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/search',
  qs: { q: 'q' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/search?q=q")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/search?q=q");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/search"

querystring = {"q":"q"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

q
string
required

Search query string

 

/tracks/{id}

Display an individual Track's metadata

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/id
curl --request GET \
  --url https://api.labs.fm/tracks/id
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/id");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
    "id": "157d7fbd-a8dc-4d12-9787-f0de321a8aba",
    "title": "Shake It Off",
    "isrc": "USCJY1431349",
    "genre": "Pop",
    "explicit": false,
    "popularity": 30,
    "preview": "https://audio-ssl.itunes.apple.com/apple-assets-us-std-000001/Music3/v4/b8/b3/7a/b8b37a93-2154-34da-74fc-8e8a316979a8/mzaf_7991652075174454658.plus.aac.p.m4a",
    "external_ids": {
        "apple": 907242707,
        "deezer": 371739291,
        "genius": 499725,
        "google": "B77k2zu72vwtsbppimfblbcgupa",
        "joox": "R8_6j+aiGIiSxuPhj++l5A==",
        "musicbrainz": "95cac6d6-125d-42be-b735-17ae5db887df",
        "musixmatch": 73447624,
        "spotify": "5xTtaWoae3wi06K5WfVUUH"
    },
    "external_urls": {
        "apple": "https://itunes.apple.com/us/album/shake-it-off/907242701?i=907242707&uo=4",
        "deezer": "https://www.deezer.com/track/371739291",
        "genius": "https://genius.com/Taylor-swift-shake-it-off-lyrics",
        "google": "https://play.google.com/store/music/album/We_Love_Taylor_Swift_Shake_It_Off?id=B77k2zu72vwtsbppimfblbcgupa",
        "musicbrainz": "https://musicbrainz.org/recording/95cac6d6-125d-42be-b735-17ae5db887df",
        "musixmatch": "https://www.musixmatch.com/lyrics/Taylor-Swift/Shake-It-Off-2",
        "spotify": "https://open.spotify.com/track/5xTtaWoae3wi06K5WfVUUH"
    },
    "artist": {
        "id": "b45bf0cf-f7a9-42d1-a20b-0322856b7420",
        "name": "Taylor Swift",
        "type": "person",
        "gender": "female",
        "country": "US",
        "popularity": 88,
        "images": [
            {
                "width": 665,
                "height": 665,
                "url": "http://images.recast.fm/artists/b45bf0cf-f7a9-42d1-a20b-0322856b7420/665x665.jpg"
            },
            {
                "width": 665,
                "height": 665,
                "url": "http://images.recast.fm/artists/b45bf0cf-f7a9-42d1-a20b-0322856b7420/665x665.jpg"
            },
            {
                "width": 983,
                "height": 983,
                "url": "http://images.recast.fm/artists/b45bf0cf-f7a9-42d1-a20b-0322856b7420/983x983.jpg"
            }
        ],
        "external_ids": {
            "allmusic": "mn0000472102",
            "apple": 159260351,
            "bbc": "20244d07-534f-4eff-b4d4-930878889970",
            "deezer": 12246,
            "discogs": 1124645,
            "facebook": "TaylorSwift",
            "genius": 1177,
            "google": "A4saifqiazru565jhrrm6d72jaa",
            "imdb": "nm2357847",
            "instagram": "taylorswift",
            "joox": 11921,
            "last.fm": "Taylor+Swift",
            "musicbrainz": "20244d07-534f-4eff-b4d4-930878889970",
            "songkick": 217815,
            "spotify": "06HL4z0CvFAxyc27GXpf02",
            "twitter": "taylorswift13",
            "youtube": "UCqECaJ8Gagnn7YCbPEzWH6g"
        },
        "external_urls": {
            "allmusic": "http://www.allmusic.com/artist/mn0000472102",
            "apple": "https://itunes.apple.com/us/artist/taylor-swift/159260351?uo=4",
            "bbc": "http://www.bbc.co.uk/music/artists/20244d07-534f-4eff-b4d4-930878889970",
            "deezer": "https://www.deezer.com/artist/12246",
            "discogs": "https://www.discogs.com/artist/1124645",
            "facebook": "https://www.facebook.com/TaylorSwift",
            "genius": "https://genius.com/artists/Taylor-swift",
            "google": "https://play.google.com/store/music/artist/Taylor_Swift?id=A4saifqiazru565jhrrm6d72jaa",
            "imdb": "http://www.imdb.com/name/nm2357847/",
            "instagram": "http://instagram.com/taylorswift/",
            "last.fm": "http://www.last.fm/music/Taylor+Swift",
            "musicbrainz": "https://musicbrainz.org/artist/20244d07-534f-4eff-b4d4-930878889970",
            "official": "http://www.bigmachinelabelgroup.com/artist/taylor-swift/",
            "songkick": "http://www.songkick.com/artists/217815-taylor-swift?utm_source=40182&utm_medium=partner",
            "spotify": "https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02",
            "twitter": "https://twitter.com/taylorswift13",
            "wikipedia": "https://en.wikipedia.org/wiki/Taylor_Swift",
            "youtube": "https://www.youtube.com/channel/UCqECaJ8Gagnn7YCbPEzWH6g"
        }
    },
    "album": {
        "id": "7002b18f-5cc0-449a-a13a-b1b361cec345",
        "type": "album",
        "title": "1989",
        "artwork": {
            "images": [
                {
                    "width": 600,
                    "height": 600,
                    "url": "http://images.recast.fm/releases/7002b18f-5cc0-449a-a13a-b1b361cec345/600x600.jpg"
                },
                {
                    "width": 1000,
                    "height": 1000,
                    "url": "http://images.recast.fm/releases/7002b18f-5cc0-449a-a13a-b1b361cec345/1000x1000.jpg"
                },
                {
                    "width": 1200,
                    "height": 1200,
                    "url": "http://images.recast.fm/releases/7002b18f-5cc0-449a-a13a-b1b361cec345/1200x1200.jpg"
                }
            ]
        },
        "released": {
            "date": "2014-10-27",
            "year": 2014
        },
        "external_ids": {
            "apple": 907242701,
            "deezer": 42906821,
            "joox": 656743,
            "spotify": "2QJmrSgbdM35R67eoGQo4j"
        },
        "external_urls": {
            "apple": "https://itunes.apple.com/us/album/id907242701",
            "deezer": "https://www.deezer.com/album/42906821",
            "spotify": "https://open.spotify.com/album/2QJmrSgbdM35R67eoGQo4j"
        },
        "labels": [
            {
                "id": "e5ce9aa4-b21d-4806-92e8-6815767fe975",
                "name": "Big Machine Records",
                "country": "US"
            }
        ]
    }
}

Path Params

id
string
required
 

/tracks/{service}:{id}

Display an individual Track's metadata by referencing a third-party unique identifier

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/service:id
curl --request GET \
  --url https://api.labs.fm/tracks/spotify:id
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/spotify:id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/spotify:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/spotify:id");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/spotify:id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

service
string
required

Lower-case service name. Supported services can be discovered in the track external_ids information.

id
string
required

The unique identifier for the track in the third-party service

 

This track reference method can also be used to access all endpoints nested below the /tracks/{id} endpoint, by replacing the {id} format with the {service}:{id} reference format.

Custom catalogue integrations

For Enterprise customers, we are able to integrate your existing catalogue so that you can make reference to tracks using your internal identifiers, allowing seamless integration of your catalogue, and Labs.fm API functionality. Contact us about this service.

/tracks/{id}/artists

List all Artists performing on an individual Track

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/id/artists
curl --request GET \
  --url https://api.labs.fm/tracks/id/artists
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/id/artists' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/id/artists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/id/artists");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/id/artists"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

role
string

By default, all artists performing on the track will be returned. Adding a 'role' allows the list to be filtered to either 'primary' or 'secondary' (eg "featuring") artists only.

country
string

Filter the artists to those from an individual country, with an official 2-letter country code (eg 'US')

gender
string

Filter the artists to those of a particular gender - either 'male' or 'female'

 

/tracks/{id}/stations

List all Stations that have played an individual Track over the last 7 day period

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/id/stations
curl --request GET \
  --url https://api.labs.fm/tracks/id/stations
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/id/stations' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/id/stations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/id/stations");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/id/stations"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string

Limit the stations to those from a particular country by specifying a two-letter official country code.

now
boolean

Set to true to limit the stations to those busy playing the track

 

/tracks/{id}/charts

List all current Chart positions for an individual Track, including position history

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/id/charts
curl --request GET \
  --url https://api.labs.fm/tracks/id/charts
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/id/charts' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/id/charts")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/id/charts");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/id/charts"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string

Limit the stations to those from a particular country by specifying a two-letter official country code.

 

/tracks/{id}/playlists

List all current Playlist positions for an individual Track, including position history

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/id/playlists
curl --request GET \
  --url https://api.labs.fm/tracks/id/playlists
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/id/playlists' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/id/playlists")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/id/playlists");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/id/playlists"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

country
string

Limit the stations to those from a particular country by specifying a two-letter official country code.

 

/tracks/{id}/labels

List all Labels associated with an individual Track

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/id/labels
curl --request GET \
  --url https://api.labs.fm/tracks/id/labels
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/id/labels' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/id/labels")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/id/labels");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/id/labels"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

role
string

By default, all artists performing on the track will be returned. Adding a 'role' allows the list to be filtered to either 'primary' or 'secondary' (eg "featuring") artists only.

 

/tracks/{id}/remixes

List any remix Tracks of an individual Track

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/id/remixes
curl --request GET \
  --url https://api.labs.fm/tracks/id/remixes
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/id/remixes' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/id/remixes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/id/remixes");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/id/remixes"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

/tracks/{id}/popularity

Displays the popularity history for an individual Track

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/id/popularity
curl --request GET \
  --url https://api.labs.fm/tracks/id/popularity
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/id/popularity' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/id/popularity")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/id/popularity");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/id/popularity"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

/tracks/{id}/preview

Retrieve an audio preview for an individual Track

 
gethttps://api.labs.fm/tracks/id/preview
curl --request GET \
  --url https://api.labs.fm/tracks/id/preview
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/id/preview' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/id/preview")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/id/preview");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/id/preview"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

This endpoint returns an actual playable audio file, which allows an end user to preview a Track. In most cases, they are 30 seconds in duration, though they may be as long as 60 seconds in some cases.

Under no condition may you download or otherwise cache these files yourselves, and must always refer to the endpoint instead.

/tracks/{id}/related

List Tracks that are related to an individual Track

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/tracks/id/related
curl --request GET \
  --url https://api.labs.fm/tracks/id/related
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/tracks/id/related' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/tracks/id/related")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/tracks/id/related");

xhr.send(data);
import requests

url = "https://api.labs.fm/tracks/id/related"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Query Params

released
date

Filter the Tracks to those which have been released since a supplied date

 

Related Tacks are based on a machine-learning recommendation engine which relates Tracks based on their characteristics, as well as any associations between them, such as artist collaborations and listening overlap. For this reason, results are related but not necessarily similar acoustically.

/reports

List all Reports that an API account has access to

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/reports
curl --request GET \
  --url https://api.labs.fm/reports
var request = require("request");

var options = { method: 'GET', url: 'https://api.labs.fm/reports' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/reports")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/reports");

xhr.send(data);
import requests

url = "https://api.labs.fm/reports"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 

In the case that a partner has custom Labs.fm reports - for example a custom chart - the /reports endpoint allows for a list of these available reports to be retrieved. The latest data for each report can be retrieved from the /reports/{id} endpoint.

/reports/{id}

Display full current data for an individual Report

 

Query Auth

 Authentication is required for this endpoint.
gethttps://api.labs.fm/reports/id
curl --request GET \
  --url https://api.labs.fm/reports/id
var request = require("request");

var options = { method: 'GET',
  url: 'https://api.labs.fm/reports/id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://api.labs.fm/reports/id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.labs.fm/reports/id");

xhr.send(data);
import requests

url = "https://api.labs.fm/reports/id"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required
 

In the case that a partner has custom Labs.fm reports - for example a custom chart - the /reports/{id} endpoint allows for this data to be retrieved via an API endpoint. This makes it possible to, for example, integrate custom reports into applications.