NAV
Shell Javascript/Axios Java/Unirest Kotlin/Fuel Swift Ruby

About

One of the principles behind IGDB.com is accessibility of data. We wish to share the data with anyone who wants to build cool video game oriented websites, apps and services.
This means that you are not only contributing to the value of this IGDB but to thousands of other projects as well. We are looking forward to see what exciting game related projects you come up with. Happy coding!
For a high level overview of our juicy data, check out the endpoints section.

The Basics

In order to use our API, you must have an account and key.

The IGDB.com API is free for non-commercial & commercial usage.

The Structure of a Request

REST Examples

You can find some examples by clicking here.

Apicalypse Wrappers

Third Party Wrappers

Need support?

Click here if you are using Browser Javascript or Ionic framework and have CORS issues.

Access community support by either using our Discord channel or contact us directly by chatting with us - Go here and click the little box on the bottom right.


Examples

Examples

Postman setup

A very basic example in Java to retrieve the name for 10 games.

https://api-v3.igdb.com/games/

fields name; limit 10;

Get all information from a specific game

1942, is the ID of a game.

https://api-v3.igdb.com/games/

fields *; where id = 1942;

Exclude irrelevant data from your query

Remove tags from your result query

https://api-v3.igdb.com/pulses/

fields *;
exclude tags;

Get all games from specific genres

Notice how you can comma separate multiple IDs (8, 9, and 11). You can do this with games, companies and anything else. Also note that when you have multiple IDs they have to be surrounded by a parenthesis. Single ids can be queried both with and without the parenthesis.

https://api-v3.igdb.com/genres/

fields *; where id = (8,9,11);

Count total games that have a rating higher than 75

https://api-v3.igdb.com/games/count

where rating > 75;

Order by popularity

https://api-v3.igdb.com/games/

fields name,popularity; sort popularity desc;

Coming soon games for Playstation 4

https://api-v3.igdb.com/release_dates/

fields *; where game.platforms = 48 & date > 1538129354; sort date asc;

1538129354: Is the timestamp in milliseconds of 28/09/2018 (This you need to generate yourself) 48 Is the platform id of Playstation 4.

Recently released games for Playstation 4

fields *; where game.platforms = 48 & date < 1538129354; sort date desc;

Search, return certain fields.

https://api-v3.igdb.com/games/

search "Halo"; fields name,release_date.human;

https://api-v3.igdb.com/games/

fields name, involved_companies; search "Halo";

Search games but exclude versions (editions)

https://api-v3.igdb.com/games/

fields name, involved_companies; search "Assassins Creed"; where version_parent = null;

This will return search results with ID and name of the game but exclude editions such as “Collectors Edition”.

Searching all endpoints

The example below searches for “Sonic the Hedgehog” which will find the Character Sonic, the collection Soninc the Hedgehog. And of course also several games with names containing Sonic the Hedgehog.

https://api-v3.igdb.com/search

fields *; search "sonic the hedgehog"; limit 50;

Get versions (editions) of a game

https://api-v3.igdb.com/game_version/

fields games.*; where game.id = 28540;

The resulting object will contain all games that are a version of the game with id 28540

Get the parent game for a version

https://api-v3.igdb.com/games/

fields version_parent.*; where id = 39047;

The resulting object will contain all main games

Get all games that are playstation 4 exclusives

fields name,category,platforms;
where category = 0 & platforms = 48;

Get all games that are only released on playstation 4 AND pc

fields name,category,platforms;
where category = 0 & platforms = {48,6};

Migration To v3

What’s changed?

What is Apicalypse?

Apicalypse is a simple query language that allows you to easily GET data from API’s. The query can be attached to any GET request as a URL parameter or in the body of the request.

If your HTTP client does not support a GET body, you can use a POST method instead.

Conversion Tool

Convert legacy query string to Apicalypse

Legacy URL:

Apicalypse Request:


Endpoints

Achievement

curl 'https://api-v3.igdb.com/achievements' \
-d 'fields achievement_icon,category,created_at,description,external_id,game,language,name,owners,owners_percentage,rank,slug,tags,updated_at;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/achievements",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields achievement_icon,category,created_at,description,external_id,game,language,name,owners,owners_percentage,rank,slug,tags,updated_at;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/achievements")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields achievement_icon,category,created_at,description,external_id,game,language,name,owners,owners_percentage,rank,slug,tags,updated_at;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/achievements".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields achievement_icon,category,created_at,description,external_id,game,language,name,owners,owners_percentage,rank,slug,tags,updated_at;").responseString()
let url = URL(string: "https://api-v3.igdb.com/achievements")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields achievement_icon,category,created_at,description,external_id,game,language,name,owners,owners_percentage,rank,slug,tags,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/achievements'), {'user-key' => YOUR_KEY})
request.body = 'fields achievement_icon,category,created_at,description,external_id,game,language,name,owners,owners_percentage,rank,slug,tags,updated_at;'
puts http.request(request).body

Achievement data for specific games for specific platforms (currently limited to acheivements from steam, playstation and Xbox)

Request Path

https://api-v3.igdb.com/achievements

field type description
achievement_icon Reference ID for Achievement Icon The icon of a specific achievement
category Category Enum The platform that a specific achievement belongs to
created_at Unix Time Stamp Date this was initially added to the IGDB database
description String The text explaining how to unlock an achievement
external_id String The ID given to the achievement by the external service
game Reference ID for Game The ID of the game an achievement is connected to
language Language Enum The ID of a region
name String The name of the achievement
owners_percentage Double Approximate percentage of players that have unlocked an achievement
rank Rank Enum ID of an Achievement Rank
slug String A url-safe, unique, lower-case version of the name
tags Array of Tag Numbers Related entities in the IGDB API
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database

Achievement Enums

rank

name value
Bronze 1
Silver 2
Gold 3
Platinum 4

category

name value
Playstation 1
Xbox 2
Steam 3

language

name value
Europe 1
North_America 2
Australia 3
New Zeland 4
Japan 5
China 6
Asia 7
Worldwide 8
Hong Kong 9
South Korea 10

Achievement Icon

curl 'https://api-v3.igdb.com/achievement_icons' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/achievement_icons",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/achievement_icons")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/achievement_icons".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()
let url = URL(string: "https://api-v3.igdb.com/achievement_icons")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/achievement_icons'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

An icon for a specific achievement

Request Path

https://api-v3.igdb.com/achievement_icons

field type description
alpha_channel boolean
animated boolean
height Integer The height of the image in pixels
image_id String The ID of the image used to construct an IGDB image link
url String The website address (URL) of the item
width Integer The width of the image in pixels

Age Rating

curl 'https://api-v3.igdb.com/age_ratings' \
-d 'fields category,content_descriptions,rating,rating_cover_url,synopsis;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/age_ratings",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,content_descriptions,rating,rating_cover_url,synopsis;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/age_ratings")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,content_descriptions,rating,rating_cover_url,synopsis;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/age_ratings".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,content_descriptions,rating,rating_cover_url,synopsis;").responseString()
let url = URL(string: "https://api-v3.igdb.com/age_ratings")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,content_descriptions,rating,rating_cover_url,synopsis;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/age_ratings'), {'user-key' => YOUR_KEY})
request.body = 'fields category,content_descriptions,rating,rating_cover_url,synopsis;'
puts http.request(request).body

Age Rating according to various rating organisations

Request Path

https://api-v3.igdb.com/age_ratings

field type description
category Category Enum The organization that has issued a specific rating
content_descriptions Reference ID for Age Rating Content Description
rating Rating Enum The title of an age rating
rating_cover_url String The url for the image of a age rating
synopsis String A free text motivating a rating

Age Rating Enums

category

name value
ESRB 1
PEGI 2

rating

name value
Three 1
Seven 2
Twelve 3
Sixteen 4
Eighteen 5
RP 6
EC 7
E 8
E10 9
T 10
M 11
AO 12

Age Rating Content Description

curl 'https://api-v3.igdb.com/age_rating_content_descriptions' \
-d 'fields category,description;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/age_rating_content_descriptions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,description;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/age_rating_content_descriptions")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,description;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/age_rating_content_descriptions".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,description;").responseString()
let url = URL(string: "https://api-v3.igdb.com/age_rating_content_descriptions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,description;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/age_rating_content_descriptions'), {'user-key' => YOUR_KEY})
request.body = 'fields category,description;'
puts http.request(request).body

The organisation behind a specific rating

Request Path

https://api-v3.igdb.com/age_rating_content_descriptions

field type description
category Category Enum
description String

Age Rating Content Description Enums

category

name value
PEGI 1
ESRB 2

Alternative Name

curl 'https://api-v3.igdb.com/alternative_names' \
-d 'fields comment,game,name;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/alternative_names",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields comment,game,name;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/alternative_names")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields comment,game,name;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/alternative_names".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields comment,game,name;").responseString()
let url = URL(string: "https://api-v3.igdb.com/alternative_names")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields comment,game,name;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/alternative_names'), {'user-key' => YOUR_KEY})
request.body = 'fields comment,game,name;'
puts http.request(request).body

Alternative and international game titles

Request Path

https://api-v3.igdb.com/alternative_names

field type description
comment String A description of what kind of alternative name it is (Acronym, Working title, Japanese title etc)
game Reference ID for Game The game this alternative name is associated with
name String An alternative name

Artwork

curl 'https://api-v3.igdb.com/artworks' \
-d 'fields alpha_channel,animated,game,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/artworks",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,game,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/artworks")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,game,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/artworks".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,game,height,image_id,url,width;").responseString()
let url = URL(string: "https://api-v3.igdb.com/artworks")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,game,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/artworks'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,game,height,image_id,url,width;'
puts http.request(request).body

official artworks (resolution and aspect ratio may vary)

Request Path

https://api-v3.igdb.com/artworks

field type description
alpha_channel boolean
animated boolean
game Reference ID for Game The game this artwork is associated with
height Integer The height of the image in pixels
image_id String The ID of the image used to construct an IGDB image link
url String The website address (URL) of the item
width Integer The width of the image in pixels

Character

curl 'https://api-v3.igdb.com/characters' \
-d 'fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/characters",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/characters")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/characters".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/characters")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/characters'), {'user-key' => YOUR_KEY})
request.body = 'fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;'
puts http.request(request).body

Video game characters

Request Path

https://api-v3.igdb.com/characters

field type description
akas Array of Strings Alternative names for a character
country_name String A characters country of origin
created_at Unix Time Stamp Date this was initially added to the IGDB database
description String A text describing a character
games Array of Game IDs
gender Gender Enum
mug_shot Reference ID for Character Mug Shot An image depciting a character
name String
people Array of People IDs Only accessible for Pro & Enterprise users
slug String A url-safe, unique, lower-case version of the name
species Species Enum
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item

Character Enums

gender

name value
Male 1
Female 2
Other 3

species

name value
Human 1
Alien 2
Animal 3
Android 4
Unknown 5

Character Mug Shot

curl 'https://api-v3.igdb.com/character_mug_shots' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/character_mug_shots",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/character_mug_shots")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/character_mug_shots".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()
let url = URL(string: "https://api-v3.igdb.com/character_mug_shots")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/character_mug_shots'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

Images depicting game characters

Request Path

https://api-v3.igdb.com/character_mug_shots

field type description
alpha_channel boolean
animated boolean
height Integer The height of the image in pixels
image_id String The ID of the image used to construct an IGDB image link
url String The website address (URL) of the item
width Integer The width of the image in pixels

Collection

curl 'https://api-v3.igdb.com/collections' \
-d 'fields created_at,games,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/collections",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,games,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/collections")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,games,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/collections".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,games,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/collections")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,games,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/collections'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,games,name,slug,updated_at,url;'
puts http.request(request).body

Collection, AKA Series

Request Path

https://api-v3.igdb.com/collections

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
games Array of Game IDs The games that are associated with this collection
name String Umbrella term for a collection of games
slug String A url-safe, unique, lower-case version of the name
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item

Company

curl 'https://api-v3.igdb.com/companies' \
-d 'fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/companies",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/companies")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/companies".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;").responseString()
let url = URL(string: "https://api-v3.igdb.com/companies")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/companies'), {'user-key' => YOUR_KEY})
request.body = 'fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;'
puts http.request(request).body

Video game companies. Both publishers & developers

Request Path

https://api-v3.igdb.com/companies

field type description
change_date Unix Time Stamp The data when a company got a new ID
change_date_category Change Date Category Enum
changed_company_id Reference ID for Company The new ID for a company that has gone through a merger or restructuring
country Integer ISO 3166-1 country code
created_at Unix Time Stamp Date this was initially added to the IGDB database
description String A free text description of a company
developed Reference ID for Game An array of games that a company has developed
logo Reference ID for Company Logo The company’s logo
name String
parent Reference ID for Company A company with a controlling interest in a specific company
published Reference ID for Game An array of games that a company has published
slug String A url-safe, unique, lower-case version of the name
start_date Unix Time Stamp The date a company was founded
start_date_category Start Date Category Enum
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item
websites Reference ID for Company Website The companies official websites

Company Enums

start_date_category

name value
YYYYMMMMDD 0
YYYYMMMM 1
YYYY 2
YYYYQ1 3
YYYYQ2 4
YYYYQ3 5
YYYYQ4 6
TBD 7

change_date_category

name value
YYYYMMMMDD 0
YYYYMMMM 1
YYYY 2
YYYYQ1 3
YYYYQ2 4
YYYYQ3 5
YYYYQ4 6
TBD 7
curl 'https://api-v3.igdb.com/company_logos' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/company_logos",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/company_logos")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/company_logos".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()
let url = URL(string: "https://api-v3.igdb.com/company_logos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/company_logos'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

The logos of developers and publishers

Request Path

https://api-v3.igdb.com/company_logos

field type description
alpha_channel boolean
animated boolean
height Integer The height of the image in pixels
image_id String The ID of the image used to construct an IGDB image link
url String The website address (URL) of the item
width Integer The width of the image in pixels

Company Website

curl 'https://api-v3.igdb.com/company_websites' \
-d 'fields category,trusted,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/company_websites",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,trusted,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/company_websites")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,trusted,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/company_websites".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,trusted,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/company_websites")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,trusted,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/company_websites'), {'user-key' => YOUR_KEY})
request.body = 'fields category,trusted,url;'
puts http.request(request).body

Company Website

Request Path

https://api-v3.igdb.com/company_websites

field type description
category Category Enum The service this website links to
trusted boolean
url String The website address (URL) of the item

Company Website Enums

category

name value
official 1
wikia 2
wikipedia 3
facebook 4
twitter 5
twitch 6
instagram 8
youtube 9
iphone 10
ipad 11
android 12
steam 13
reddit 14
discord 15
google_plus 16
tumblr 17
linkedin 18
pinterest 19
soundcloud 20

Cover

curl 'https://api-v3.igdb.com/covers' \
-d 'fields alpha_channel,animated,game,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/covers",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,game,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/covers")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,game,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/covers".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,game,height,image_id,url,width;").responseString()
let url = URL(string: "https://api-v3.igdb.com/covers")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,game,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/covers'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,game,height,image_id,url,width;'
puts http.request(request).body

The cover art of games

Request Path

https://api-v3.igdb.com/covers

field type description
alpha_channel boolean
animated boolean
game Reference ID for Game The game this cover is associated with
height Integer The height of the image in pixels
image_id String The ID of the image used to construct an IGDB image link
url String The website address (URL) of the item
width Integer The width of the image in pixels

External Game

curl 'https://api-v3.igdb.com/external_games' \
-d 'fields category,created_at,game,name,uid,updated_at,url,year;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/external_games",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,created_at,game,name,uid,updated_at,url,year;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/external_games")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,created_at,game,name,uid,updated_at,url,year;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/external_games".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,created_at,game,name,uid,updated_at,url,year;").responseString()
let url = URL(string: "https://api-v3.igdb.com/external_games")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,created_at,game,name,uid,updated_at,url,year;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/external_games'), {'user-key' => YOUR_KEY})
request.body = 'fields category,created_at,game,name,uid,updated_at,url,year;'
puts http.request(request).body

Game IDs on other services

Request Path

https://api-v3.igdb.com/external_games

field type description
category Category Enum The id of the other service
created_at Unix Time Stamp Date this was initially added to the IGDB database
game Reference ID for Game The IGDB ID of the game
name String The name of the game according to the other service
uid String The other services ID for this game
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item
year Integer The year in full (2018)

External Game Enums

category

name value
steam 1
gog 5
youtube 10
microsoft 11
apple 13
twitch 14
android 15

Feed

curl 'https://api-v3.igdb.com/feeds' \
-d 'fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/feeds",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/feeds")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/feeds".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;").responseString()
let url = URL(string: "https://api-v3.igdb.com/feeds")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/feeds'), {'user-key' => YOUR_KEY})
request.body = 'fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;'
puts http.request(request).body

Feed items are a social feed of status updates, media and news articles.

Request Path

https://api-v3.igdb.com/feeds

field type description
category Category Enum The type of feed item
content String The content of the feed item
created_at Unix Time Stamp Date this was initially added to the IGDB database
feed_likes_count Integer Number of likes this feed item has
feed_video Reference ID for Game Video A video associated with this feed item
games Array of Game IDs The games connected to this feed item
meta String Other meta data
published_at Unix Time Stamp The date this item was initially published by the third party
pulse Reference ID for Pulse The pulse article associated with this feed item
slug String A url-safe, unique, lower-case version of the name
title String Title of the feed item (usually blank)
uid String A unique ID
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item
user Integer The user who created the feed item

Feed Enums

category

name value
pulse_article 1
coming_soon 2
new_trailer 3
user_contributed_item 5
user_contributions_item 6
page_contributed_item 7

Franchise

curl 'https://api-v3.igdb.com/franchises' \
-d 'fields created_at,games,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/franchises",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,games,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/franchises")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,games,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/franchises".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,games,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/franchises")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,games,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/franchises'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,games,name,slug,updated_at,url;'
puts http.request(request).body

A list of video game franchises such as Star Wars.

Request Path

https://api-v3.igdb.com/franchises

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
games Array of Game IDs The games that are associated with this franchise
name String The name of the franchise
slug String A url-safe, unique, lower-case version of the name
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item

Game

curl 'https://api-v3.igdb.com/games' \
-d 'fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/games",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/games")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/games".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;").responseString()
let url = URL(string: "https://api-v3.igdb.com/games")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/games'), {'user-key' => YOUR_KEY})
request.body = 'fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;'
puts http.request(request).body

Video Games!

Request Path

https://api-v3.igdb.com/games

field type description
age_ratings Reference ID for Age Rating The PEGI rating
aggregated_rating Double Rating based on external critic scores
aggregated_rating_count Integer Number of external critic scores
alternative_names Array of Alternative Name IDs Alternative names for this game
artworks Array of Artwork IDs Artworks of this game
bundles Reference ID for Game If a bundle, these are the games inside it
category Category Enum The category of this game
collection Reference ID for Collection The series the game belongs to
cover Reference ID for Cover The cover of this game
created_at Unix Time Stamp Date this was initially added to the IGDB database
dlcs Reference ID for Game DLCs for this game
expansions Reference ID for Game Expansions of this game
external_games Array of External Game IDs External IDs this game has on other services
first_release_date Unix Time Stamp The first release date for this game
follows Integer Number of people following a game
franchise Reference ID for Franchise The main franchise
franchises Array of Franchise IDs Other franchises the game belongs to
game_engines Array of Game Engine IDs The game engine used in this game
game_modes Array of Game Mode IDs Modes of gameplay
genres Array of Genre IDs Genres of the game
hypes Integer Number of follows a game gets before release
involved_companies Array of Involved Company IDs Companies who developed this game
keywords Array of Keyword IDs Associated keywords
multiplayer_modes Array of Multiplayer Mode IDs Multiplayer modes for this game
name String
parent_game Reference ID for Game If a DLC, expansion or part of a bundle, this is the main game or bundle
platforms Array of Platform IDs Platforms this game was released on
player_perspectives Array of Player Perspective IDs The main perspective of the player
popularity Double The popularity score of the game
pulse_count Integer Number of pulse articles for this game
rating Double Average IGDB user rating
rating_count Integer Total number of IGDB user ratings
release_dates Array of Release Date IDs Release dates of this game
screenshots Array of Screenshot IDs Screenshots of this game
similar_games Reference ID for Game Similar games
slug String A url-safe, unique, lower-case version of the name
standalone_expansions Reference ID for Game Standalone expansions of this game
status Status Enum The status of the games release
storyline String A short description of a games story
summary String A description of the game
tags Array of Tag Numbers Related entities in the IGDB API
themes Array of Theme IDs Themes of the game
time_to_beat Reference ID for Time To Beat How long the game takes to be completed
total_rating Double Average rating based on both IGDB user and external critic scores
total_rating_count Integer Total number of user and external critic scores
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item
version_parent Reference ID for Game If a version, this is the main game
version_title String Title of this version (i.e Gold edition)
videos Reference ID for Game Video Videos of this game
websites Reference ID for Website Websites associated with this game

Game Enums

category

name value
main_game 0
dlc_addon 1
expansion 2
bundle 3
standalone_expansion 4

status

name value
released 0
alpha 2
beta 3
early_access 4
offline 5
cancelled 6

Game Engine

curl 'https://api-v3.igdb.com/game_engines' \
-d 'fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/game_engines",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_engines")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/game_engines".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/game_engines")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/game_engines'), {'user-key' => YOUR_KEY})
request.body = 'fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;'
puts http.request(request).body

Video game engines such as unreal engine.

Request Path

https://api-v3.igdb.com/game_engines

field type description
companies Array of Company IDs Companies who used this game engine
created_at Unix Time Stamp Date this was initially added to the IGDB database
description String Description of the game engine
logo Reference ID for Game Engine Logo Logo of the game engine
name String Name of the game engine
platforms Array of Platform IDs Platforms this game engine was deployed on
slug String A url-safe, unique, lower-case version of the name
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item
curl 'https://api-v3.igdb.com/game_engine_logos' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/game_engine_logos",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_engine_logos")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/game_engine_logos".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()
let url = URL(string: "https://api-v3.igdb.com/game_engine_logos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/game_engine_logos'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

The logos of game engines

Request Path

https://api-v3.igdb.com/game_engine_logos

field type description
alpha_channel boolean
animated boolean
height Integer The height of the image in pixels
image_id String The ID of the image used to construct an IGDB image link
url String The website address (URL) of the item
width Integer The width of the image in pixels

Game Version

curl 'https://api-v3.igdb.com/game_versions' \
-d 'fields created_at,features,game,games,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/game_versions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,features,game,games,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_versions")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,features,game,games,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/game_versions".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,features,game,games,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/game_versions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,features,game,games,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/game_versions'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,features,game,games,updated_at,url;'
puts http.request(request).body

Details about game editions and versions.

Request Path

https://api-v3.igdb.com/game_versions

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
features Reference ID for Game Version Feature Features and descriptions of what makes each version/edition different from the main game
game Reference ID for Game The game these versions/editions are of
games Array of Game IDs Game Versions and Editions
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item

Game Mode

curl 'https://api-v3.igdb.com/game_modes' \
-d 'fields created_at,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/game_modes",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_modes")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/game_modes".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/game_modes")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/game_modes'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,name,slug,updated_at,url;'
puts http.request(request).body

Single player, Multiplayer etc

Request Path

https://api-v3.igdb.com/game_modes

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
name String The name of the game mode
slug String A url-safe, unique, lower-case version of the name
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item

Game Version Feature

curl 'https://api-v3.igdb.com/game_version_features' \
-d 'fields category,description,position,title,values;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/game_version_features",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,description,position,title,values;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_version_features")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,description,position,title,values;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/game_version_features".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,description,position,title,values;").responseString()
let url = URL(string: "https://api-v3.igdb.com/game_version_features")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,description,position,title,values;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/game_version_features'), {'user-key' => YOUR_KEY})
request.body = 'fields category,description,position,title,values;'
puts http.request(request).body

Features and descriptions of what makes each version/edition different from the main game

Request Path

https://api-v3.igdb.com/game_version_features

field type description
category Category Enum The category of the feature description
description String The description of the feature
position Integer Position of this feature in the list of features
title String The title of the feature
values Reference ID for Game Version Feature Value The bool/text value of the feature

Game Version Feature Enums

category

name value
boolean 0
description 1

Game Version Feature Value

curl 'https://api-v3.igdb.com/game_version_feature_values' \
-d 'fields game,game_feature,included_feature,note;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/game_version_feature_values",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields game,game_feature,included_feature,note;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_version_feature_values")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields game,game_feature,included_feature,note;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/game_version_feature_values".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields game,game_feature,included_feature,note;").responseString()
let url = URL(string: "https://api-v3.igdb.com/game_version_feature_values")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields game,game_feature,included_feature,note;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/game_version_feature_values'), {'user-key' => YOUR_KEY})
request.body = 'fields game,game_feature,included_feature,note;'
puts http.request(request).body

The bool/text value of the feature

Request Path

https://api-v3.igdb.com/game_version_feature_values

field type description
game Reference ID for Game The version/edition this value refers to
game_feature Reference ID for Game Version Feature The id of the game feature
included_feature Included Feature Enum The boole value of this feature
note String The text value of this feature

Game Version Feature Value Enums

included_feature

name value
NOT_INCLUDED 0
INCLUDED 1
PRE_ORDER_ONLY 2

Game Video

curl 'https://api-v3.igdb.com/game_videos' \
-d 'fields game,name,video_id;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/game_videos",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields game,name,video_id;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_videos")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields game,name,video_id;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/game_videos".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields game,name,video_id;").responseString()
let url = URL(string: "https://api-v3.igdb.com/game_videos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields game,name,video_id;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/game_videos'), {'user-key' => YOUR_KEY})
request.body = 'fields game,name,video_id;'
puts http.request(request).body

A video associated with a game

Request Path

https://api-v3.igdb.com/game_videos

field type description
game Reference ID for Game The game this video is associated with
name String The name of the video
video_id String The external ID of the video (usually youtube)

Genre

curl 'https://api-v3.igdb.com/genres' \
-d 'fields created_at,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/genres",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/genres")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/genres".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/genres")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/genres'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,name,slug,updated_at,url;'
puts http.request(request).body

Genres of video game

Request Path

https://api-v3.igdb.com/genres

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
name String
slug String A url-safe, unique, lower-case version of the name
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item

Involved Company

curl 'https://api-v3.igdb.com/involved_companies' \
-d 'fields company,created_at,developer,game,porting,publisher,supporting,updated_at;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/involved_companies",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields company,created_at,developer,game,porting,publisher,supporting,updated_at;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/involved_companies")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields company,created_at,developer,game,porting,publisher,supporting,updated_at;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/involved_companies".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields company,created_at,developer,game,porting,publisher,supporting,updated_at;").responseString()
let url = URL(string: "https://api-v3.igdb.com/involved_companies")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields company,created_at,developer,game,porting,publisher,supporting,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/involved_companies'), {'user-key' => YOUR_KEY})
request.body = 'fields company,created_at,developer,game,porting,publisher,supporting,updated_at;'
puts http.request(request).body

Request Path

https://api-v3.igdb.com/involved_companies

field type description
company Reference ID for Company
created_at Unix Time Stamp Date this was initially added to the IGDB database
developer boolean
game Reference ID for Game
porting boolean
publisher boolean
supporting boolean
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database

Keyword

curl 'https://api-v3.igdb.com/keywords' \
-d 'fields created_at,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/keywords",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/keywords")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/keywords".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/keywords")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/keywords'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,name,slug,updated_at,url;'
puts http.request(request).body

Keywords are words or phrases that get tagged to a game such as “world war 2” or “steampunk”.

Request Path

https://api-v3.igdb.com/keywords

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
name String
slug String A url-safe, unique, lower-case version of the name
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item

Multiplayer Mode

curl 'https://api-v3.igdb.com/multiplayer_modes' \
-d 'fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/multiplayer_modes",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/multiplayer_modes")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/multiplayer_modes".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;").responseString()
let url = URL(string: "https://api-v3.igdb.com/multiplayer_modes")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/multiplayer_modes'), {'user-key' => YOUR_KEY})
request.body = 'fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;'
puts http.request(request).body

Data about the supported multiplayer types

Request Path

https://api-v3.igdb.com/multiplayer_modes

field type description
campaigncoop boolean True if the game supports campaign coop
dropin boolean True if the game supports drop in/out multiplayer
game Reference ID for Game The game this multiplayer mode is associated with
lancoop boolean True if the game supports LAN coop
offlinecoop boolean True if the game supports offline coop
offlinecoopmax Integer Maximum number of offline players in offline coop
offlinemax Integer Maximum number of players in offline multiplayer
onlinecoop boolean True if the game supports online coop
onlinecoopmax Integer Maximum number of online players in online coop
onlinemax Integer Maximum number of players in online multiplayer
platform Reference ID for Platform The platform this multiplayer mode refers to
splitscreen boolean True if the game supports split screen, offline multiplayer
splitscreenonline boolean True if the game supports split screen, online multiplayer

Page

curl 'https://api-v3.igdb.com/pages' \
-d 'fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/pages",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/pages")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/pages".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;").responseString()
let url = URL(string: "https://api-v3.igdb.com/pages")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/pages'), {'user-key' => YOUR_KEY})
request.body = 'fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;'
puts http.request(request).body

Our multipurpose page system is currently used for youtubers and media organisations.

Request Path

https://api-v3.igdb.com/pages

field type description
background Reference ID for Page Background The page background
battlenet String A battlenet ID
category Category Enum The type (category) of this page
color Color Enum The main color of this page
company Reference ID for Company The company this page is about
country Integer ISO 3166-1 country code
created_at Unix Time Stamp Date this was initially added to the IGDB database
description String A description
feed Reference ID for Feed The id of the feed for this page
game Reference ID for Game The game this page is about
name String The page name
origin String An Origin ID
page_follows_count Integer The number of followers this page has
page_logo Reference ID for Page Logo The page logo
slug String A url-safe, unique, lower-case version of the name
sub_category Sub Category Enum The subcategory
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
uplay String A uplay ID
url String The website address (URL) of the item
user Reference ID for User The user who has write permissions to this page
websites Reference ID for Page Website

Page Enums

color

name value
green 0
blue 1
red 2
orange 3
pink 4
yellow 5

category

name value
personality 1
media_organization 2
content_creator 3
clan_team 4

sub_category

name value
user 1
game 2
company 3
consumer 4
industry 5
e_sports 6

Page Background

curl 'https://api-v3.igdb.com/page_backgrounds' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/page_backgrounds",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/page_backgrounds")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/page_backgrounds".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()
let url = URL(string: "https://api-v3.igdb.com/page_backgrounds")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/page_backgrounds'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

Background of a page

Request Path

https://api-v3.igdb.com/page_backgrounds

field type description
alpha_channel boolean
animated boolean
height Integer The height of the image in pixels
image_id String The ID of the image used to construct an IGDB image link
url String The website address (URL) of the item
width Integer The width of the image in pixels
curl 'https://api-v3.igdb.com/page_logos' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/page_logos",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/page_logos")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/page_logos".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()
let url = URL(string: "https://api-v3.igdb.com/page_logos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/page_logos'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

Logo for a page

Request Path

https://api-v3.igdb.com/page_logos

field type description
alpha_channel boolean
animated boolean
height Integer The height of the image in pixels
image_id String The ID of the image used to construct an IGDB image link
url String The website address (URL) of the item
width Integer The width of the image in pixels

Page Website

curl 'https://api-v3.igdb.com/page_websites' \
-d 'fields category,trusted,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/page_websites",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,trusted,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/page_websites")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,trusted,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/page_websites".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,trusted,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/page_websites")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,trusted,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/page_websites'), {'user-key' => YOUR_KEY})
request.body = 'fields category,trusted,url;'
puts http.request(request).body

Page Website

Request Path

https://api-v3.igdb.com/page_websites

field type description
category Category Enum The service this website links to
trusted boolean
url String The website address (URL) of the item

Page Website Enums

category

name value
official 1
wikia 2
wikipedia 3
facebook 4
twitter 5
twitch 6
instagram 8
youtube 9
iphone 10
ipad 11
android 12
steam 13
reddit 14
discord 15
google_plus 16
tumblr 17
linkedin 18
pinterest 19
soundcloud 20

Platform

curl 'https://api-v3.igdb.com/platforms' \
-d 'fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/platforms",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/platforms")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/platforms".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;").responseString()
let url = URL(string: "https://api-v3.igdb.com/platforms")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/platforms'), {'user-key' => YOUR_KEY})
request.body = 'fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;'
puts http.request(request).body

The hardware used to run the game or game delivery network

Request Path

https://api-v3.igdb.com/platforms

field type description
abbreviation String An abbreviation of the platform name
alternative_name String An alternative name for the platform
category Category Enum A physical or virtual category of the platform
created_at Unix Time Stamp Date this was initially added to the IGDB database
generation Integer The generation of the platform
name String The name of the platform
platform_logo Reference ID for Platform Logo The logo of the first Version of this platform
product_family Reference ID for Product Family The family of platforms this one belongs to
slug String A url-safe, unique, lower-case version of the name
summary String The summary of the first Version of this platform
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item
versions Reference ID for Platform Version Associated versions of this platform
websites Reference ID for Platform Website The main website

Platform Enums

category

name value
console 1
arcade 2
platform 3
operating_system 4
portable_console 5
computer 6
curl 'https://api-v3.igdb.com/platform_logos' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/platform_logos",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/platform_logos")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/platform_logos".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()
let url = URL(string: "https://api-v3.igdb.com/platform_logos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/platform_logos'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

Logo for a platform

Request Path

https://api-v3.igdb.com/platform_logos

field type description
alpha_channel boolean
animated boolean
height Integer The height of the image in pixels
image_id String The ID of the image used to construct an IGDB image link
url String The website address (URL) of the item
width Integer The width of the image in pixels

Platform Version

curl 'https://api-v3.igdb.com/platform_versions' \
-d 'fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/platform_versions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/platform_versions")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/platform_versions".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/platform_versions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/platform_versions'), {'user-key' => YOUR_KEY})
request.body = 'fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;'
puts http.request(request).body

Request Path

https://api-v3.igdb.com/platform_versions

field type description
companies Reference ID for Platform Version Company Who developed this platform version
connectivity String The network capabilities
cpu String The integrated control processing unit
graphics String The graphics chipset
main_manufacturer Reference ID for Platform Version Company Who manufactured this version of the platform
media String The type of media this version accepted
memory String How much memory there is
name String The name of the platform version
os String The operating system installed on the platform version
output String The output video rate
platform_logo Reference ID for Platform Logo The logo of this platform version
platform_version_release_dates Array of Platform Version Release Date IDs When this platform was released
resolutions String The maximum resolution
slug String A url-safe, unique, lower-case version of the name
sound String The sound chipset
storage String How much storage there is
summary String A short summary
url String The website address (URL) of the item

Platform Version Company

curl 'https://api-v3.igdb.com/platform_version_companies' \
-d 'fields comment,company,developer,manufacturer;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/platform_version_companies",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields comment,company,developer,manufacturer;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/platform_version_companies")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields comment,company,developer,manufacturer;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/platform_version_companies".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields comment,company,developer,manufacturer;").responseString()
let url = URL(string: "https://api-v3.igdb.com/platform_version_companies")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields comment,company,developer,manufacturer;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/platform_version_companies'), {'user-key' => YOUR_KEY})
request.body = 'fields comment,company,developer,manufacturer;'
puts http.request(request).body

A platform developer

Request Path

https://api-v3.igdb.com/platform_version_companies

field type description
comment String Any notable comments about the developer
company Reference ID for Company The company responsible for developing this platform version
developer boolean
manufacturer boolean

Platform Version Release Date

curl 'https://api-v3.igdb.com/platform_version_release_dates' \
-d 'fields category,created_at,date,human,m,platform_version,region,updated_at,y;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/platform_version_release_dates",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,created_at,date,human,m,platform_version,region,updated_at,y;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/platform_version_release_dates")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,created_at,date,human,m,platform_version,region,updated_at,y;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/platform_version_release_dates".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,created_at,date,human,m,platform_version,region,updated_at,y;").responseString()
let url = URL(string: "https://api-v3.igdb.com/platform_version_release_dates")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,created_at,date,human,m,platform_version,region,updated_at,y;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/platform_version_release_dates'), {'user-key' => YOUR_KEY})
request.body = 'fields category,created_at,date,human,m,platform_version,region,updated_at,y;'
puts http.request(request).body

A handy endpoint that extends platform release dates. Used to dig deeper into release dates, platforms and versions.

Request Path

https://api-v3.igdb.com/platform_version_release_dates

field type description
category Category Enum The format of the release date
created_at Unix Time Stamp Date this was initially added to the IGDB database
date Unix Time Stamp The release date
human String A human readable version of the release date
m Integer The month as an integer starting at 1 (January)
platform_version Reference ID for Platform Version The platform this release date is for
region Region Enum The region of the release
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
y Integer The year in full (2018)

Platform Version Release Date Enums

category

name value
YYYYMMMMDD 0
YYYYMMMM 1
YYYY 2
YYYYQ1 3
YYYYQ2 4
YYYYQ3 5
YYYYQ4 6
TBD 7

region

name value
europe 1
north_america 2
australia 3
new_zealand 4
japan 5
china 6
asia 7
worldwide 8

Platform Website

curl 'https://api-v3.igdb.com/platform_websites' \
-d 'fields category,trusted,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/platform_websites",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,trusted,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/platform_websites")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,trusted,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/platform_websites".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,trusted,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/platform_websites")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,trusted,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/platform_websites'), {'user-key' => YOUR_KEY})
request.body = 'fields category,trusted,url;'
puts http.request(request).body

The main website for the platform

Request Path

https://api-v3.igdb.com/platform_websites

field type description
category Category Enum The service this website links to
trusted boolean
url String The website address (URL) of the item

Platform Website Enums

category

name value
official 1
wikia 2
wikipedia 3
facebook 4
twitter 5
twitch 6
instagram 8
youtube 9
iphone 10
ipad 11
android 12
steam 13
reddit 14
discord 15
google_plus 16
tumblr 17
linkedin 18
pinterest 19
soundcloud 20

Player Perspective

curl 'https://api-v3.igdb.com/player_perspectives' \
-d 'fields created_at,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/player_perspectives",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/player_perspectives")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/player_perspectives".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/player_perspectives")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/player_perspectives'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,name,slug,updated_at,url;'
puts http.request(request).body

Player perspectives describe the view/perspective of the player in a video game.

Request Path

https://api-v3.igdb.com/player_perspectives

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
name String
slug String A url-safe, unique, lower-case version of the name
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item

Product Family

curl 'https://api-v3.igdb.com/product_families' \
-d 'fields name,slug;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/product_families",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields name,slug;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/product_families")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields name,slug;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/product_families".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields name,slug;").responseString()
let url = URL(string: "https://api-v3.igdb.com/product_families")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields name,slug;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/product_families'), {'user-key' => YOUR_KEY})
request.body = 'fields name,slug;'
puts http.request(request).body

A collection of closely related platforms

Request Path

https://api-v3.igdb.com/product_families

field type description
name String The name of the product family
slug String A url-safe, unique, lower-case version of the name

Pulse

curl 'https://api-v3.igdb.com/pulses' \
-d 'fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/pulses",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/pulses")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/pulses".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;").responseString()
let url = URL(string: "https://api-v3.igdb.com/pulses")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/pulses'), {'user-key' => YOUR_KEY})
request.body = 'fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;'
puts http.request(request).body

A single news article.

Request Path

https://api-v3.igdb.com/pulses

field type description
author String The author of the article according to the publisher
created_at Unix Time Stamp Date this was initially added to the IGDB database
image String The url of the main image of the article
published_at Unix Time Stamp The date this item was initially published by the third party
pulse_source Reference ID for Pulse Source The ID of the publisher
summary String A brief extract of the article
tags Array of Tag Numbers Related entities in the IGDB API
title String The title of the article
uid String A unique ID for this article
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
videos Array of Strings Any videos embedded in the article
website Reference ID for Pulse Url

Pulse Group

curl 'https://api-v3.igdb.com/pulse_groups' \
-d 'fields created_at,game,name,published_at,pulses,tags,updated_at;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/pulse_groups",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,game,name,published_at,pulses,tags,updated_at;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/pulse_groups")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,game,name,published_at,pulses,tags,updated_at;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/pulse_groups".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,game,name,published_at,pulses,tags,updated_at;").responseString()
let url = URL(string: "https://api-v3.igdb.com/pulse_groups")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,game,name,published_at,pulses,tags,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/pulse_groups'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,game,name,published_at,pulses,tags,updated_at;'
puts http.request(request).body

Pulse groups are a combined array of news articles that are about a specific game and were published around the same time period.

Request Path

https://api-v3.igdb.com/pulse_groups

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
game Reference ID for Game The game these articles are about
name String
published_at Unix Time Stamp The date this item was initially published by the third party
pulses Array of Pulse IDs The articles within this pulse group
tags Array of Tag Numbers Related entities in the IGDB API
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database

Pulse Source

curl 'https://api-v3.igdb.com/pulse_sources' \
-d 'fields game,name,page;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/pulse_sources",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields game,name,page;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/pulse_sources")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields game,name,page;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/pulse_sources".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields game,name,page;").responseString()
let url = URL(string: "https://api-v3.igdb.com/pulse_sources")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields game,name,page;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/pulse_sources'), {'user-key' => YOUR_KEY})
request.body = 'fields game,name,page;'
puts http.request(request).body

A news article source such as IGN.

Request Path

https://api-v3.igdb.com/pulse_sources

field type description
game Reference ID for Game If the source only contains news for a specific game, that game ID will be here
name String Name of the article’s publisher
page Reference ID for Page The related page that contains more information about the source

Pulse Url

curl 'https://api-v3.igdb.com/pulse_urls' \
-d 'fields trusted,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/pulse_urls",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields trusted,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/pulse_urls")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields trusted,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/pulse_urls".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields trusted,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/pulse_urls")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields trusted,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/pulse_urls'), {'user-key' => YOUR_KEY})
request.body = 'fields trusted,url;'
puts http.request(request).body

A URL linking to the article

Request Path

https://api-v3.igdb.com/pulse_urls

field type description
trusted boolean
url String The website address (URL) of the item

Release Date

curl 'https://api-v3.igdb.com/release_dates' \
-d 'fields category,created_at,date,game,human,m,platform,region,updated_at,y;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/release_dates",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,created_at,date,game,human,m,platform,region,updated_at,y;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/release_dates")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,created_at,date,game,human,m,platform,region,updated_at,y;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/release_dates".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,created_at,date,game,human,m,platform,region,updated_at,y;").responseString()
let url = URL(string: "https://api-v3.igdb.com/release_dates")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,created_at,date,game,human,m,platform,region,updated_at,y;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/release_dates'), {'user-key' => YOUR_KEY})
request.body = 'fields category,created_at,date,game,human,m,platform,region,updated_at,y;'
puts http.request(request).body

A handy endpoint that extends game release dates. Used to dig deeper into release dates, platforms and versions.

Request Path

https://api-v3.igdb.com/release_dates

field type description
category Category Enum The format category of the release date
created_at Unix Time Stamp Date this was initially added to the IGDB database
date Unix Time Stamp The date of the release
game Reference ID for Game
human String A human readable representation of the date
m Integer The month as an integer starting at 1 (January)
platform Reference ID for Platform The platform of the release
region Region Enum The region of the release
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
y Integer The year in full (2018)

Release Date Enums

category

name value
YYYYMMMMDD 0
YYYYMMMM 1
YYYY 2
YYYYQ1 3
YYYYQ2 4
YYYYQ3 5
YYYYQ4 6
TBD 7

region

name value
europe 1
north_america 2
australia 3
new_zealand 4
japan 5
china 6
asia 7
worldwide 8

Screenshot

curl 'https://api-v3.igdb.com/screenshots' \
-d 'fields alpha_channel,animated,game,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/screenshots",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,game,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/screenshots")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,game,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/screenshots".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,game,height,image_id,url,width;").responseString()
let url = URL(string: "https://api-v3.igdb.com/screenshots")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,game,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/screenshots'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,game,height,image_id,url,width;'
puts http.request(request).body

Screenshots of games

Request Path

https://api-v3.igdb.com/screenshots

field type description
alpha_channel boolean
animated boolean
game Reference ID for Game The game this video is associated with
height Integer The height of the image in pixels
image_id String The ID of the image used to construct an IGDB image link
url String The website address (URL) of the item
width Integer The width of the image in pixels
curl 'https://api-v3.igdb.com/search' \
-d 'fields alternative_name,character,collection,company,description,game,name,person,platform,popularity,published_at,test_dummy,theme;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/search",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alternative_name,character,collection,company,description,game,name,person,platform,popularity,published_at,test_dummy,theme;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/search")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alternative_name,character,collection,company,description,game,name,person,platform,popularity,published_at,test_dummy,theme;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/search".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alternative_name,character,collection,company,description,game,name,person,platform,popularity,published_at,test_dummy,theme;").responseString()
let url = URL(string: "https://api-v3.igdb.com/search")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alternative_name,character,collection,company,description,game,name,person,platform,popularity,published_at,test_dummy,theme;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/search'), {'user-key' => YOUR_KEY})
request.body = 'fields alternative_name,character,collection,company,description,game,name,person,platform,popularity,published_at,test_dummy,theme;'
puts http.request(request).body

Request Path

https://api-v3.igdb.com/search

field type description
alternative_name String
character Reference ID for Character
collection Reference ID for Collection
company Reference ID for Company
description String
game Reference ID for Game
name String
person Reference ID for Person
platform Reference ID for Platform
popularity Double
published_at Unix Time Stamp The date this item was initially published by the third party
test_dummy Reference ID for Test Dummy
theme Reference ID for Theme

Theme

curl 'https://api-v3.igdb.com/themes' \
-d 'fields created_at,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/themes",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/themes")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/themes".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/themes")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/themes'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,name,slug,updated_at,url;'
puts http.request(request).body

Video game themes

Request Path

https://api-v3.igdb.com/themes

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
name String
slug String A url-safe, unique, lower-case version of the name
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item

Title

curl 'https://api-v3.igdb.com/titles' \
-d 'fields created_at,description,games,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/titles",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,description,games,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/titles")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,description,games,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/titles".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,description,games,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/titles")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,description,games,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/titles'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,description,games,name,slug,updated_at,url;'
puts http.request(request).body

Job titles in the games industry

Request Path

https://api-v3.igdb.com/titles

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
description String A description of the job role
games Array of Game IDs Games that utilised this job role during development or production
name String Name of the job role
slug String A url-safe, unique, lower-case version of the name
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item

Time To Beat

curl 'https://api-v3.igdb.com/time_to_beats' \
-d 'fields completely,game,hastly,normally;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/time_to_beats",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields completely,game,hastly,normally;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/time_to_beats")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields completely,game,hastly,normally;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/time_to_beats".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields completely,game,hastly,normally;").responseString()
let url = URL(string: "https://api-v3.igdb.com/time_to_beats")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields completely,game,hastly,normally;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/time_to_beats'), {'user-key' => YOUR_KEY})
request.body = 'fields completely,game,hastly,normally;'
puts http.request(request).body

Average completion times for games

Request Path

https://api-v3.igdb.com/time_to_beats

field type description
completely Integer The time this game was completed in while the players were completing all tasks the game had to offer
game Reference ID for Game The game this time-to-beat is connected to
hastly Integer The time this game was completed in while the players were rushing through
normally Integer The time this game was completed in while the players were playing through while relaxed

Website

curl 'https://api-v3.igdb.com/websites' \
-d 'fields category,game,trusted,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/websites",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,game,trusted,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/websites")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,game,trusted,url;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/websites".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,game,trusted,url;").responseString()
let url = URL(string: "https://api-v3.igdb.com/websites")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,game,trusted,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/websites'), {'user-key' => YOUR_KEY})
request.body = 'fields category,game,trusted,url;'
puts http.request(request).body

A website url, usually associated with a game

Request Path

https://api-v3.igdb.com/websites

field type description
category Category Enum The service this website links to
game Reference ID for Game The game this website is associated with
trusted boolean
url String The website address (URL) of the item

Website Enums

category

name value
official 1
wikia 2
wikipedia 3
facebook 4
twitter 5
twitch 6
instagram 8
youtube 9
iphone 10
ipad 11
android 12
steam 13
reddit 14
discord 15
google_plus 16
tumblr 17
linkedin 18
pinterest 19
soundcloud 20

Private Endpoints

Feed Follow

curl 'https://api-v3.igdb.com/private/feed_follows' \
-d 'fields created_at,feed,published_at,updated_at,user;limit 50;' \
-H 'user-key: API_KEY' \
-H 'authorize: bearer OAUTH_TOKEN' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/private/feed_follows",
  method: "POST",
  headers: {
      "Accept": "application/json",
      "user-key": API_KEY
      "Authorize": "bearer " + OAUTH_TOKEN
  },
  data: "fields created_at,feed,published_at,updated_at,user;limit 50;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/private/feed_follows")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .header("Authorize", "bearer " + OAUTH_TOKEN)
  .body("fields created_at,feed,published_at,updated_at,user;limit 50;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/private/feed_follows".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json", "Authorize" to "bearer " + OAUTH_TOKEN)
  .body("fields created_at,feed,published_at,updated_at,user;limit 50;").responseString()
let url = URL(string: "https://api-v3.igdb.com/private/feed_follows")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = Data(base64Encoded: "fields created_at,feed,published_at,updated_at,user;limit 50;")
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
requestHeader.setValue("bearer " + OAUTH_TOKEN, forHTTPHeaderField: "Authorize")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/private/feed_follows'), {'user-key' => YOUR_KEY, 'accept' => 'application/json', 'Authorize' => "bearer " + OAUTH_TOKEN})
request.body = 'fields created_at,feed,published_at,updated_at,user;limit 50;'
puts http.request(request).body

Request Path

https://api-v3.igdb.com/private/feed_follows

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
feed Feed Enum
published_at Unix Time Stamp The date this item was initially published by the third party
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
user Reference ID for User A user who subscribes to a feed item

Feed Follow Enums

feed

name value
pulse_article 1
coming_soon 2
new_trailer 3
user_contributed_item 5
user_contributions_item 6
page_contributed_item 7

Follow

curl 'https://api-v3.igdb.com/private/follows' \
-d 'fields game,user;limit 50;' \
-H 'user-key: API_KEY' \
-H 'authorize: bearer OAUTH_TOKEN' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/private/follows",
  method: "POST",
  headers: {
      "Accept": "application/json",
      "user-key": API_KEY
      "Authorize": "bearer " + OAUTH_TOKEN
  },
  data: "fields game,user;limit 50;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/private/follows")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .header("Authorize", "bearer " + OAUTH_TOKEN)
  .body("fields game,user;limit 50;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/private/follows".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json", "Authorize" to "bearer " + OAUTH_TOKEN)
  .body("fields game,user;limit 50;").responseString()
let url = URL(string: "https://api-v3.igdb.com/private/follows")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = Data(base64Encoded: "fields game,user;limit 50;")
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
requestHeader.setValue("bearer " + OAUTH_TOKEN, forHTTPHeaderField: "Authorize")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/private/follows'), {'user-key' => YOUR_KEY, 'accept' => 'application/json', 'Authorize' => "bearer " + OAUTH_TOKEN})
request.body = 'fields game,user;limit 50;'
puts http.request(request).body

Request Path

https://api-v3.igdb.com/private/follows

field type description
game Reference ID for Game
user Reference ID for User

List

curl 'https://api-v3.igdb.com/private/lists' \
-d 'fields created_at,description,entries_count,list_entries,list_tags,listed_games,name,numbering,private,similar_lists,slug,updated_at,url,user;limit 50;' \
-H 'user-key: API_KEY' \
-H 'authorize: bearer OAUTH_TOKEN' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/private/lists",
  method: "POST",
  headers: {
      "Accept": "application/json",
      "user-key": API_KEY
      "Authorize": "bearer " + OAUTH_TOKEN
  },
  data: "fields created_at,description,entries_count,list_entries,list_tags,listed_games,name,numbering,private,similar_lists,slug,updated_at,url,user;limit 50;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/private/lists")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .header("Authorize", "bearer " + OAUTH_TOKEN)
  .body("fields created_at,description,entries_count,list_entries,list_tags,listed_games,name,numbering,private,similar_lists,slug,updated_at,url,user;limit 50;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/private/lists".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json", "Authorize" to "bearer " + OAUTH_TOKEN)
  .body("fields created_at,description,entries_count,list_entries,list_tags,listed_games,name,numbering,private,similar_lists,slug,updated_at,url,user;limit 50;").responseString()
let url = URL(string: "https://api-v3.igdb.com/private/lists")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = Data(base64Encoded: "fields created_at,description,entries_count,list_entries,list_tags,listed_games,name,numbering,private,similar_lists,slug,updated_at,url,user;limit 50;")
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
requestHeader.setValue("bearer " + OAUTH_TOKEN, forHTTPHeaderField: "Authorize")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/private/lists'), {'user-key' => YOUR_KEY, 'accept' => 'application/json', 'Authorize' => "bearer " + OAUTH_TOKEN})
request.body = 'fields created_at,description,entries_count,list_entries,list_tags,listed_games,name,numbering,private,similar_lists,slug,updated_at,url,user;limit 50;'
puts http.request(request).body

Request Path

https://api-v3.igdb.com/private/lists

field type description
created_at Unix Time Stamp Date this was initially added to the IGDB database
description String
entries_count Integer
list_entries Array of List Entry IDs
list_tags Array of Integers
listed_games Reference ID for Game
name String
numbering boolean
private boolean
similar_lists Reference ID for List
slug String A url-safe, unique, lower-case version of the name
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item
user Reference ID for User

List Entry

curl 'https://api-v3.igdb.com/private/list_entries' \
-d 'fields description,game,list,platform,position,private,user;limit 50;' \
-H 'user-key: API_KEY' \
-H 'authorize: bearer OAUTH_TOKEN' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/private/list_entries",
  method: "POST",
  headers: {
      "Accept": "application/json",
      "user-key": API_KEY
      "Authorize": "bearer " + OAUTH_TOKEN
  },
  data: "fields description,game,list,platform,position,private,user;limit 50;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/private/list_entries")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .header("Authorize", "bearer " + OAUTH_TOKEN)
  .body("fields description,game,list,platform,position,private,user;limit 50;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/private/list_entries".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json", "Authorize" to "bearer " + OAUTH_TOKEN)
  .body("fields description,game,list,platform,position,private,user;limit 50;").responseString()
let url = URL(string: "https://api-v3.igdb.com/private/list_entries")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = Data(base64Encoded: "fields description,game,list,platform,position,private,user;limit 50;")
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
requestHeader.setValue("bearer " + OAUTH_TOKEN, forHTTPHeaderField: "Authorize")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/private/list_entries'), {'user-key' => YOUR_KEY, 'accept' => 'application/json', 'Authorize' => "bearer " + OAUTH_TOKEN})
request.body = 'fields description,game,list,platform,position,private,user;limit 50;'
puts http.request(request).body

Request Path

https://api-v3.igdb.com/private/list_entries

field type description
description String
game Reference ID for Game
list Reference ID for List
platform Reference ID for Platform
position Integer
private boolean
user Reference ID for User

Rate

curl 'https://api-v3.igdb.com/private/rates' \
-d 'fields game,rating,user;limit 50;' \
-H 'user-key: API_KEY' \
-H 'authorize: bearer OAUTH_TOKEN' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/private/rates",
  method: "POST",
  headers: {
      "Accept": "application/json",
      "user-key": API_KEY
      "Authorize": "bearer " + OAUTH_TOKEN
  },
  data: "fields game,rating,user;limit 50;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/private/rates")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .header("Authorize", "bearer " + OAUTH_TOKEN)
  .body("fields game,rating,user;limit 50;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/private/rates".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json", "Authorize" to "bearer " + OAUTH_TOKEN)
  .body("fields game,rating,user;limit 50;").responseString()
let url = URL(string: "https://api-v3.igdb.com/private/rates")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = Data(base64Encoded: "fields game,rating,user;limit 50;")
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
requestHeader.setValue("bearer " + OAUTH_TOKEN, forHTTPHeaderField: "Authorize")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/private/rates'), {'user-key' => YOUR_KEY, 'accept' => 'application/json', 'Authorize' => "bearer " + OAUTH_TOKEN})
request.body = 'fields game,rating,user;limit 50;'
puts http.request(request).body

Request Path

https://api-v3.igdb.com/private/rates

field type description
game Reference ID for Game
rating Double
user Reference ID for User

Review

curl 'https://api-v3.igdb.com/private/reviews' \
-d 'fields category,conclusion,content,created_at,game,introduction,likes,negative_points,platform,positive_points,slug,title,updated_at,url,user,user_rating,video,views;limit 50;' \
-H 'user-key: API_KEY' \
-H 'authorize: bearer OAUTH_TOKEN' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/private/reviews",
  method: "POST",
  headers: {
      "Accept": "application/json",
      "user-key": API_KEY
      "Authorize": "bearer " + OAUTH_TOKEN
  },
  data: "fields category,conclusion,content,created_at,game,introduction,likes,negative_points,platform,positive_points,slug,title,updated_at,url,user,user_rating,video,views;limit 50;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/private/reviews")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .header("Authorize", "bearer " + OAUTH_TOKEN)
  .body("fields category,conclusion,content,created_at,game,introduction,likes,negative_points,platform,positive_points,slug,title,updated_at,url,user,user_rating,video,views;limit 50;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/private/reviews".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json", "Authorize" to "bearer " + OAUTH_TOKEN)
  .body("fields category,conclusion,content,created_at,game,introduction,likes,negative_points,platform,positive_points,slug,title,updated_at,url,user,user_rating,video,views;limit 50;").responseString()
let url = URL(string: "https://api-v3.igdb.com/private/reviews")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = Data(base64Encoded: "fields category,conclusion,content,created_at,game,introduction,likes,negative_points,platform,positive_points,slug,title,updated_at,url,user,user_rating,video,views;limit 50;")
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
requestHeader.setValue("bearer " + OAUTH_TOKEN, forHTTPHeaderField: "Authorize")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/private/reviews'), {'user-key' => YOUR_KEY, 'accept' => 'application/json', 'Authorize' => "bearer " + OAUTH_TOKEN})
request.body = 'fields category,conclusion,content,created_at,game,introduction,likes,negative_points,platform,positive_points,slug,title,updated_at,url,user,user_rating,video,views;limit 50;'
puts http.request(request).body

Reviews published by users at IGDB.com

Request Path

https://api-v3.igdb.com/private/reviews

field type description
category Category Enum The medium of this review
conclusion String The conclusion section of the review
content String The main content of the review
created_at Unix Time Stamp Date this was initially added to the IGDB database
game Reference ID for Game The game this review was written about
introduction String An introduction to the review
likes Integer The number of likes this review has received from other users
negative_points String A few negative points about the game
platform Reference ID for Platform The platform the game was played on
positive_points String A few positive points about the game
slug String A url-safe, unique, lower-case version of the name
title String The title of the review
updated_at Unix Time Stamp The last date this entry was updated in the IGDB database
url String The website address (URL) of the item
user Reference ID for User
user_rating Reference ID for Rate The rating given by the reviewer
video Reference ID for Review Video The URL of the video that contains the review
views Integer The number of views this review has received from other users

Review Enums

category

name value
text 1
video 2

Review Video

curl 'https://api-v3.igdb.com/private/review_videos' \
-d 'fields trusted,url;limit 50;' \
-H 'user-key: API_KEY' \
-H 'authorize: bearer OAUTH_TOKEN' \
-H 'Accept: application/json'
axios({
  url: "https://api-v3.igdb.com/private/review_videos",
  method: "POST",
  headers: {
      "Accept": "application/json",
      "user-key": API_KEY
      "Authorize": "bearer " + OAUTH_TOKEN
  },
  data: "fields trusted,url;limit 50;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/private/review_videos")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .header("Authorize", "bearer " + OAUTH_TOKEN)
  .body("fields trusted,url;limit 50;")
  .asJson();
val (request, response, result) = "https://api-v3.igdb.com/private/review_videos".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json", "Authorize" to "bearer " + OAUTH_TOKEN)
  .body("fields trusted,url;limit 50;").responseString()
let url = URL(string: "https://api-v3.igdb.com/private/review_videos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = Data(base64Encoded: "fields trusted,url;limit 50;")
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
requestHeader.setValue("bearer " + OAUTH_TOKEN, forHTTPHeaderField: "Authorize")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com', 80)
request = Net::HTTP::Get.new(URI('https://api-v3.igdb.com/private/review_videos'), {'user-key' => YOUR_KEY, 'accept' => 'application/json', 'Authorize' => "bearer " + OAUTH_TOKEN})
request.body = 'fields trusted,url;limit 50;'
puts http.request(request).body

Video reviews published by users at IGDB.com

Request Path

https://api-v3.igdb.com/private/review_videos

field type description
trusted boolean
url String The website address (URL) of the item

Reference

CORS for JS & Ionic

(Coming Soon!) Cross-Origin Resource Sharing

Cross-Origin Resource Sharing (CORS) is a mechanism that uses additional HTTP headers to let a user agent gain permission to access selected resources from a server on a different origin (domain) than the site currently in use. These security restrictions only affect browser-based javascript and mobile javascript frameworks like Ionic.

To enable CORS, you need to register your domain by sending a POST request to the headers endpoint. To achieve this in Postman

{
    "api_header": {
        "header": "Access-Control-Allow-Origin",
        "value": "yourdomain.com"
    }
}

Future responses from the API will contain the special header required to access the API. Access-Control-Allow-Origin: yourdomain.com

To delete the header, send a DELETE request to /headers/?header=Access-Control-Allow-Origin.

IGDB Authentication

IGDB authentication will allow your app to access and store IGDB user information such as:

IGDB Authentication follows the Oauth2 standard. The urls you need are:

The credentials you need are:

The Authentication button should look like the image below.

Image Assets can be found here

Sample projects

We have made two sample projects which you can find here:

Using the AccessToken

When you have the access token you have the IGDB users permission to look at their data. You can use this token on four endpoints to get specific information about this user. To use the access token with the api you need to add an extra header on the specific endpoints. The header is: "Authorization" = "Bearer YOUR_ACCESS_TOKEN".

Private Endpoints

Adding the accesstoken to your header will give you access to that users data, even if it is set to private. The endpoints that accept accesstokens are:

User Information

The access token unlocks a extra private endpoint, /private/me, whihc returns the users info. The information returned is:

Images

Examples

Here we retrieve the image properties of the game with the id “1942”

[{
	"id": 1942,
	"screenshots": [{
			"id": 9742,
			"game": 1942,
			"height": 1080,
			"image_id": "mnljdjtrh44x4snmierh",
			"url": "//images.igdb.com/igdb/image/upload/t_thumb/mnljdjtrh44x4snmierh.jpg",
			"width": 1920
		},
		{
			"id": 9743,
			"game": 1942,
			"height": 1080,
			"image_id": "em1y2ugcwy2myuhvb9db",
			"url": "//images.igdb.com/igdb/image/upload/t_thumb/em1y2ugcwy2myuhvb9db.jpg",
			"width": 1920
		}
	]
}]

Response example on the right –>

Image url structure:

https://images.igdb.com/igdb/image/upload/t_screenshot_med_2x/dfgkfivjrhcksyymh9vw.jpg

Break down:

https://images.igdb.com/igdb/image/upload/t_{size}/{hash}.jpg

size is one of the interchangeable size types listed below. hash is the id of the image. The image sizes are all maximum size but by appending _2x to any size, you can get retina (DPR 2.0) sizes (cover_small_2x).

Name Size Extra
cover_small 90 x 128 Fit
screenshot_med 569 x 320 Lfill, Center gravity
cover_big 264 x 374 Fit
logo_med 284 x 160 Fit
screenshot_big 889 x 500 Lfill, Center gravity
screenshot_huge 1280 x 720 Lfill, Center gravity
thumb 90 x 90 Thumb, Center gravity
micro 35 x 35 Thumb, Center gravity
720p 1280 x 720 Fit, Center gravity
1080p 1920 x 1080 Fit, Center gravity

Fields

What?

Fields are properties of an entity. For example, a Game field would be genres or release_dates. Some fields have properties of their own, for example, the genres field has the property name.

Where?

Fields can be used on any entity that has sub-properties such as Games, Companies, People etc.

How?

Fields are requested in a comma separated list. For example, to get some information for some Games, Genres, Themes or anything else, you could request it like this:

Apicalypse

where id = (4356,189,444);
fields name,release_dates,genres.name,rating

Legacy Parameters

/games/4356,189,444?fields=name,release_dates,genres.name,rating

Note in Apicalypse the name property of genres can be accessed directly with a dot (genres.name).

A full list of fields can be obtained by passing a * as a field. Alternatively you can use the meta postfix: /games/meta to get a list of all fields.

Shorthand

Another way of writing fields is to use the shorthand f which achieves the same result.

f name,release_dates,genres.name,rating;
w id = (4356,189,444);

Exclude

What?

Exclude is a complement to the regular fields which allows you to request all fields with the exception of any numbers of fields specified with exclude.

How?

Fields to be excluded are specified as a comma separated list. For example, to get all fields excpect for screenshots, you could request it like this:

Apicalypse

fields *;
exclude screenshots;

Shorthand

Another way of writing exclude is to use the shorthand x which achieves the same result.

f *;
x screenshots;

Expander

What?

Some fields are actually ids pointing to another endpoint. The expander feature is a convenient way to go into these other endpoints and access more information from them in the same query, instead of having to do multiple queries.

Where?

Expands are specificed among the regular fields in the body of the query.

How?

Fields can be expanded with a dot followed by the fields you want to access from a certain endpoint.

Examples

In the example below we request the fields name and genres for the game The Witcher 3 with id 1942.

fields name,genres;
where id = 1942;

But this query will only return ids for the genres, which can be seen in the first response to the right:

"First example response showing genre ids"
[
    {
        "id ": 1942,
        "genres":[
            12,
            31
        ],
        "name": "The Witcher 3: Wild Hunt"
    }
]

For some use cases the id is all that is needed, but other times more data is needed, This is when the expander features comes in handy.

fields name,genres.name;
where id = 1942;

This example with expander retrieves the name of each genre which can be seen in the second response to the right.

"Second example response showing genre ids and name"
[
    {
        "id": 1942,
        "genres": [
            {
                "id": 12,
                "name": "Role-playing (RPG)"
            },
            {
                "id": 31,
                "name": "Adventure"
            }
        ],
        "name": "The Witcher 3: Wild Hunt"
    }
]

And lastly lets take a look at how you can use a wildcard character * to retrieve all data from genres in the previous example.

fields name,genres.*;
where id = 1942;

See the third response to the right where all available data for each genre is included in the response.

"Third example response showing all available genre data"
[
    {
        "id": 1942,
        "genres": [
            {
                "id": 12,
                "created_at": 1297555200,
                "name": "Role-playing (RPG)",
                "slug": "role-playing-rpg",
                "updated_at": 1323216000,
                "url": "https://www.igdb.com/genres/role-playing-rpg"
            },
            {
                "id": 31,
                "created_at": 1323561600,
                "name": "Adventure",
                "slug": "adventure",
                "updated_at": 1323561600,
                "url": "https://www.igdb.com/genres/adventure"
            }
        ],
        "name": "The Witcher 3: Wild Hunt"
    }
]

Cost

This feature is a little bit different from other features as it affects the cost of the queries that utilize it.

Normally all queries subtract 1 from your total number of available requests, but each expanded field in a query counts as an additional “request” towards your total number of requests.

Below are a few examples of this.

This example has a total cost of 1 since no fields are expanded.

fields name,genres;
where id = 1942;

In this example one field (genres) is expanded so the total cost becomes 2.

fields name,genres.name,genres.slug;
where id = 1942;

In this example there are a total of three expanded fields (genres, cover, and platforms) which makes the total cost of the query 4.

fields name,genres.name,cover.*,platforms.*;
where id = 1942;

Filters

What?

Filters are used to sift through results to get what you want. You can exclude and include results based on their properties. For example you could remove all Games where the rating was below 80 (where rating >= 80).

How?

Filters are parameter arrays so must be added using special keys like this:

Where?

Filters can be used on any entity that has sub-properties such as Games, Companies, People etc.

Available Postfixes

Examples

Filter by multiple platforms

To get games that are released on PS4 OR XBOX ONE OR PC

Similarly if you want games released on PS4 AND XBOX ONE AND PC

If you want games released only on PC

And if you want games released for PC OR any other platform

Combining Multiple Filters

It is possible to to use logical operators between filters, which could look something like this:

The response from this example query will be games that fulfil one or both of two sets or requirements:

Prefix, Postfix and Infix

Prefix

Filtering for game names beginning with “Super” (This will return games such as for example Super Mario World)

Postfix

Filtering for game names ending with with “World” (This will also return games such as for example Super Mario World)

Infix

Filtering for game names containing the string “Smash” (This will return games such as for example Super Smash Bros)

case insensitive version

Filtering for game names containing the string “Smash” (This will return games such as for example Super Smash Bros)

Removing erotic games from API responses

Some queries may return games with erotic themes. All erotic games in the database has the theme ‘erotic’ (id = 42). So by adding a simple filter like the one below you can remove them from your responses.

Sorting

What?

Sorting is used to order results by a specific field.

How?

You can order results like this:

Notice the appended :desc (descending) which could also be :asc (ascending) if required.

Order by popularity

Popularity parameter for games. You can access it like this:

The popularity number is calculated using usage statistics of game pages at https://www.igdb.com

Where?

Ordering can be used on any entity.

Search

What?

Search based on name, results are sorted by similarity to the given search string.

Where?

Searchable endpoints: - Characters - Collections - Games - People - Platforms - Themes

How?

You specify which endpoint to search through in the Address field of your request. The search string is then entered in the body of the request by typing search, blank space followed by the string you wish to search for.

Pagination

Here is an example for how to use limit. The default limit is 10. The maximum limit is 50, for pro it is 500, and the above tiers, the maximum limit is 5000.

There is also an offset. This will start the list at position 22 and give 33 results.

Depending on which tier of the API you are using, there is a cap on how much offset you can put on your query.

Protobuf File

Here is the link to the protobuf file: https://api-v3.igdb.com/igdbapi.proto

The protobuf file is created in accordance with the proto3 specification

You can find the protobuf file here

This file contains the mapping of the entire IGDB API and can be used to generate wrappers, code and tooling in any programming language.

Tag Numbers

Tag numbers are automatically generated numbers which provide a compact and fast way to do complex filtering on the IGDB API. The number calculation can be easily achieved with any programming language.

The basis of the calculation is a 32bit integer, where the first 4 bits contain the object type ID, and the remaining 28 bits represent the ID of the object we are generating the tag number for.

Using this method a flat index of custom object ‘hashes’ can be maintained in which index the search and filtering is faster than using conventional methods.

Currently the following object types use tags:

Type ID Name
0 Theme
1 Genre
2 Keyword
3 Game
4 Player Perspective

Let’s see two examples for tag number calculation.

// Javascript
const genreTypeID = 1; // The type ID from the table above
const shooterGenreID = 5; // The Shooter genre's ID, coming from the genres endpoint.
let tagNumber = genreTypeID << 28; // Bit-shifting the genre's type ID by 28 bits, ensuring that it will get into the first four bits. The result will be 268435456
tagNumber |= shooterGenreID; // Adding the Shooter genre ID to the tag number with a bitwise OR operation. The result will be 268435461.

We try to find all the pulses which relate to the Shooter genre. The tag number generation in Javascript would look something like the example on the right.

Javascript example query:

# Python
gameTypeID: 3 # The game's type ID from the table above/
gameID: 26196 # The ID of the game /games/crash-bandicoot-n-sane-trilogy
tagNumber: gameTypeID << 28 # Bit-shifting the game's type ID by 28 bits, ensuring that it will get into the first four bits. The result will be 805306368
tagNumber |= gameID # Adding the game ID to the tag number with a bitwise OR operation. The result will be 805332564.

Python example query:

Multi-Query

Multi-Query is a new way to request a huge amount of information in one request! With Multi-Query you can request multiple endpoints at once, it also works with multiple requests to a single endpoint as well.

A Multi-Query is made by making a POST request to: https://api-v3.igdb.com/multiquery.

Syntax Structure The Multi-Query syntax is made up of three pieces; “Endpoint name”, “Result Name (Given by you)”, and the APICalypse query inside the body {}.

important You can only run a maximum of 10 queries.

Example 1:

Get the count of platforms in the api.

query platforms/count "Count of Platforms" {
  // here we can have additional filters
};

This above query will give us the following result:

[
    {
        "name": "Count of Platforms",
        "count": 155
    }
]

Example 2:

Get Playstation 4 Exclusives

query games "Playstation Games" {
	fields name,platforms.name;
	where platforms !=n & platforms = {48};
	limit 1;
};

This above query will give us the following result:

[
    {
        "name": "Playstation Games",
        "result": [
            {
                "id": 52826,
                "name": "Skate 4",
                "platforms": [
                    {
                        "id": 48,
                        "name": "PlayStation 4"
                    }
                ]
            }
        ]
    }
]

Example 3:

Combining the queries of example 1 and 2.

query platforms/count "Count of Platforms" {
  // here we can ahve additional filters
};

query games "Playstation Games" {
	fields name,platforms.name;
	where platforms !=n & platforms = {48};
	limit 1;
};
[
    {
        "name": "Count of Platforms",
        "count": 155
    },
    {
        "name": "Playstation Games",
        "result": [
            {
                "id": 52826,
                "name": "Skate 4",
                "platforms": [
                    {
                        "id": 48,
                        "name": "PlayStation 4"
                    }
                ]
            }
        ]
    }
]

Webhooks

What?

Webhooks allow us to push data to you when it is added or updated. Instead of polling the API for changes, you can listen on your HTTP endpoint (Webhook) and we will deliver the data to you.

How to register your webhook

To register a new webhook you need to send a POST request to ENDPOINT/webhooks. The endpoint is required as it specifies what type of data you want from your webhook.

The post request should contain x-www-form-urlencoded body with three parameters:

  • url this is your prepared url that is ready to accept data from us.
  • method this is the type of data you are expecting to your url, there are three types of methods

    • create, sends new items from the API
    • delete, sends deleted items from the API
    • update, sends updated items from the API

  • secret this is your “secret” password for your webhook. Every request from the webhook service will have your secret in the header called X-Secret.

Registering your webhook in Postman

// Example webhook registration in Kotlin
val webhookURL = "https://api-v3.igdb.com/games/webhooks/"
val webhookParams = listOf("url" to "YOUR_WEBHOOK_URL", "secret" to "YOUR_WEBHOOK_SECRET", "method" to "create")
val (request, response, result) = webhookURL.httpPost(webhookParams).header("user-key" to "YOUR_API_KEY").responseString()
when (response.statusCode) {
        200 -> Logger.info("New webhook registered!")
        409 -> Logger.warning("Webhook already exists, already connected.. ")
        else -> Logger.error("Received unknown error, code: ${response.statusCode}")
}

Once your webhook is registered you will receive a response with the new webhook object

// Example response upon registering your webhook
{ 
    "id": WEBHOOK_ID, // A unique ID for the webhook
    "url": "YOUR_WEBHOOK_URL", // Your chosen URL
    "category": 1, // Based on the endpoint you chose
    "sub_category": 0, // Based on your method (can be 0, 1, 2)
    "active": true, // Is the webhook currently active
    "api_key": YOUR_API_KEY, // Displays the api key the webhook is connected to
    "secret": "YOUR_SECRET", // Your chosen secret
    "created_at": 2018-11-25T23:00:00.000Z, // Created at date
    "updated_at": 2018-11-25T23:00:00.000Z // Updated at date
}

That’s it!
The data will now be sent to your webhook in the body of a post request. The data is a single json object representing an unexpanded entity.

Webhooks have an active field, as you can see in the JSON response above, The service will keep the webhook active as long as the webhook url is capable of receiving data from the service. If the url fails 5 times the webhook will be set to inactive (active: false) and the service will stop to send data to this webhook.

Reactivating the webhook is done by re-registering it, this will update the active status to true.

Viewing your webhooks

You can always get information about your webhooks from the API.

To get ALL of your registered webhooks simply send a GET request to /webhooks, without the endpoint. This will return a JSON array of your webhooks

To get information about a specific webhook you can make a GET request with the webhook id to /webhooks/WEBHOOK_ID, without the endpoint. This will return the webhook of that id.

Removing a Webhook

To remove your existing webhook you need to send a DELETE request to /webhooks/WEBHOOK_ID, without the endpoint. The Webhook id is returned during the registration process or can be found with a GET request to /webhooks/.

The DELETE request will receive the deleted webhook as confirmation.

Testing

To make sure you have everything setup just right we have a test endpoint for the webhook service. This endpoint will send an object of your choosing to your newly created webhook.

Send a POST request to ENDPOINT/webhooks/test/WEBHOOK_ID?entityId=ENTITY_ID. The entity id is the id of the object from the endpoint you wish to test with, example:

POST to games/webhooks/test/42?entityId=1337:
This request will send the game object with id 1337 to your webhook url.

APICalypse

APICalypse cheatsheet

APICalypse is a new language used for this api which greatly simplifies how you can query your requests compared to the url parameters used in API V2.

Fields

Fields are used to select which fields you want back from your request to the api.

To select fields you need the APICalypse command fields or its shorthand f.

Popular wildcard is to add * instead of a field, this will give you all of the fields.

fields name,release_dates,genres.name,rating;

f name,release_dates,genres.name,rating;

Exclude

Commonly used with selecting all fields with the wildcard * this command will exclude the fields that you select.

To exclude fields you don’t need the APICalypse command exclude or its shorthand x.

fields *; exclude tags,keywords;

f *; x tags,keywords;

Where

Where is easiest described as a filter. With where you can filter on specific fields.

To filter your results use the APICalypse command where or its shorthand w.

fields *; where genres = 4;

f *; w genres = 4;

Limit

Limit describes how many results you will get back from the api, the standard value is 10.

To set a new limit use the APICalypse command limit or it’s shorthand l.

fields *; limit 50;

f *; l 50;

Offset

Offset describes how many results you will skip over, standard is 0.

To set a new offset use the APICalypse command offset or it’s shorthand o.
Offset is often used together with Limit for pagination.

limit 50; offset 50;

l 50; o 50;

Sort

Use Sort to order the results to your liking.

To order the results use the APICalypse command sort or it’s shorthand s.
Sort has two accompaning commands for “direction”; asc Ascending order and desc Decending order.

fields *; sort popularity asc;

f *; s popularity desc;

Search

To find a specific title you can use Search.

To use search use the APICalypse command search, it has no shorthand :(. Search has it’s own endpoint where it is good to use a filter for specific kinds of results, example where game != null; for only games.

search “Halo”; fields name;

search “Halo”; f name;

Other shorts

Null can be written null or n. Booleans can be written as true or t and false or f

API Status

What is it

The API Status endpoint is a way to see a usage report for an API key. It shows stats such as requests made in the current period and when that period ends

How to access it

To access API Status make a GETrequest to https://api-v3.igdb.com/api_status

Example response

To the right is an example of a response to /api_status from a free account

[
    {
        "authorized": true,
        "plan": "Free",
        "usage_reports": {
            "usage_report": {
                "metric": "hits",
                "period": "month",
                "period_start": "2018-12-01 00:00:00 +0000",
                "period_end": "2019-01-01 00:00:00 +0000",
                "max_value": 10000,
                "current_value": 1
            }
        }
    }
]