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.

Account Creation

In order to use our API, you must have a Twitch Account.

The IGDB.com API is free for non-commercial usage under the terms of the Twitch Developer Service Agreement.

  1. Sign Up with Twitch for a free account
  2. Ensure you have Two Factor Authentication enabled
  3. Register your application
  4. Manage your newly created application
  5. Generate a Client Secret by pressing [New Secret]
  6. Take note of the Client ID and Client Secret

Authentication

Now that you have a Client ID and Client Secret you will be authenticating as a Twitch Developer using oauth2. Detailed information can be found on the Twitch Developer Docs.

Doing so will give you an access token that is used for future requests to our API.

Make a POST request to https://id.twitch.tv/oauth2/token with the following query string parameters, substituting your Client ID and Client Secret accordingly.

client_id=Client ID

client_secret=Client Secret

grant_type=client_credentials

Example

If your Client ID is abcdefg12345 and your Client Secret is hijklmn67890, the whole url should look like the following.

https://id.twitch.tv/oauth2/token?client_id=abcdefg12345&client_secret=hijklmn67890&grant_type=client_credentials

The response from this will be a json object containing the access token and the number of second until the token expires.

{
  "access_token": "prau3ol6mg5glgek8m89ec2s9q5i3i",
  "expires_in": 5587808,
  "token_type": "bearer"
}

The expires_in shows you the number of seconds before the access_token will expire and must be refreshed.

Requests

  • Most of the requests to the API will use the POST method
  • The base URL is: https://api.igdb.com/v4
  • You define which endpoint you wish to query by appending /{endpoint name} to the base URL eg. https://api.igdb.com/v4/games
  • Include Client ID and access_token in the HEADER of your request so that your headers look like the following. Take special care of the capitalisation. Bearer should be hard-coded.
Client-ID: Client ID
Authorization: Bearer access_token
  • You use the BODY of your request to specify the fields you want to retrieve as well as any other filters, sorting etc

Example

If your Client ID is abcdefg12345 and your access_token is prau3ol6mg5glgek8m89ec2s9q5i3i, a simple request to get information about 10 games would be.

POST https://api.igdb.com/v4/games
Client-ID: abcdefg12345
Authorization: Bearer prau3ol6mg5glgek8m89ec2s9q5i3i
fields *;

More Examples

You can find some examples by clicking here.

Rate Limits

There is a rate limit of 4 requests per second. If you go over this limit you will receive a response with status code 429 Too Many Requests.

You are able to have up to 8 open requests at any moment in time. This can occur if requests take longer than 1 second to respond when multiple requests are being made.

Wrappers

Apicalypse

Third Party

Need support?

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

Access community support by using our Discord Channel.

Examples

Postman setup

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

https://api.igdb.com/v4/games/

fields name; limit 10;

Get all information from a specific game

1942, is the ID of a game.

https://api.igdb.com/v4/games/

fields *; where id = 1942;

Exclude irrelevant data from your query

Remove alternative_name from your result query

https://api.igdb.com/v4/platforms/

fields *;
exclude alternative_name;

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.igdb.com/v4/genres/

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

Count total games that have a rating higher than 75

https://api.igdb.com/v4/games/count

where rating > 75;

Order by rating

https://api.igdb.com/v4/games/

fields name,rating; sort rating desc;

Coming soon games for Playstation 4

https://api.igdb.com/v4/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.igdb.com/v4/games/

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

https://api.igdb.com/v4/games/

fields name, involved_companies; search "Halo";

Search games but exclude versions (editions)

https://api.igdb.com/v4/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.igdb.com/v4/search

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

Get versions (editions) of a game

https://api.igdb.com/v4/game_versions/

fields game.name,games.name; where game = 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.igdb.com/v4/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};

Upgrading To v4 From v3

One of the goals with our acquisition by Twitch is to provide more data to more of you, and to ensure that the data we provide is of the highest quality. With v4 we are excited to address these goals in a number of ways.

  • Allowing unlimited access to data through the complete removal of request quotas across our entire API
  • Allowing access to our complete breadth of data through the removal of offset limits
  • Increase stability for our users by implementing request rate limits
  • Integrated access to all of Twitch APIs through the migration to the Twitch Developer Program for authentication
  • Improving reliability of our data by removing unmaintained, out of date or incorrect data points

It is important to note that we hope to add many of the removed data points back again in the future, but it is imperative for us to know that if you are accessing data through our API, it is updated and supported. We cannot have applications being built upon features that do not meet our high standards.

Breaking Changes

1. Update To New API URL

API 3000 v4 uses a new url structure and sub-domain. All connections should be made to…

https://api.igdb.com/v4

2. Change GET requests to POST

One of the upgrades we have made requires us to conform with the HTTP/1.1 specification. As such, we will no longer be accepting GET requests containing a message body.

If you are utilising GET requests with a message body, you should alter your requests to use the POST method instead, otherwise you will see that v4 returns a 403 status code.

3. Recreate Webhooks

Webhooks will not be transferred to v4 and hence will need to be recreated. More documentation about webhooks can be found here.

4. Handle Newly Implemented Rate Limits

There is a rate limit of 4 requests per second. If you go over this limit you will receive a response with status code 429 Too Many Requests.

You are able to have up to 8 open requests at any moment in time. This can occur if requests take longer than 1 second to respond when multiple requests are being made.

5. Update Authentication

Authentication will be migrating away from the 3scale managed layer and instead be performed through the Twitch Developers program, using oauth.

Previously authentication was done by providing your API token in the user-key request header. On v4, the user-key header will be ignored and requests must use the following instead.

Client-ID: Twitch Developer Application Client ID
Authorization: Twitch Developer Application Access Token

Full information regarding acquiring a Client ID and Access Token can be found at https://dev.twitch.tv/docs/authentication.

However, to get started immediately:

  1. Sign Up with Twitch for a free account
  2. Ensure you have Two Factor Authentication enabled
  3. Register your application
  4. Manage your newly created application
  5. Generate a Client Secret by pressing [New Secret]
  6. Take note of the Client ID and Client Secret

Your application will then need to make a request following the OAuth client credentials flow documentation, replacing client_id and client_secret query string parameters with the values you generated earlier.

POST https://id.twitch.tv/oauth2/token?
    ?client_id=retgzhvpsxjwun0rvrb1rfwheegu1yw
    &client_secret=dfgh4h5iug3iug35g97131dgh3947u4
    &grant_type=client_credentials

The response will be a json object containing the access token and the number of seconds until the token expires.

{
   "access_token": "prau3ol6mg5glgek8m89ec2s9q5i3i",
   "expires_in": 5587808,
   "token_type": "bearer"
}

Requests can now be made to v4 specifying Client ID and Access Token within the headers Client-ID and Authorization.

POST https://api.igdb.com/v4/games
Client-ID: retgzhvpsxjwun0rvrb1rfwheegu1yw
Authorization: Bearer prau3ol6mg5glgek8m89ec2s9q5i3i

The expires_in time (seconds) should be used to calculate when you will need to authenticate again by creating a new access_token (usually > 60 days).

6. Confirm To Our New Data Structure

Changed Endpoints

The endpoints below that are marked as removed will return a 404 not found response.

Endpoint Change Dump URL
achievement_icons Removed https://d2ssegy8jiabys.cloudfront.net/achievement_icons.csv
achievements Removed https://d2ssegy8jiabys.cloudfront.net/achievements.csv
feed_follows Removed
feeds Removed
follows Removed
list_entries Removed
lists Removed
page_backgrounds Removed https://d2ssegy8jiabys.cloudfront.net/page_backgrounds.csv
page_logos Removed https://d2ssegy8jiabys.cloudfront.net/page_logos.csv
page_websites Removed https://d2ssegy8jiabys.cloudfront.net/page_websites.csv
pages Removed https://d2ssegy8jiabys.cloudfront.net/pages.csv
product_families Renamed to platform_families
pulse_images Removed https://d2ssegy8jiabys.cloudfront.net/pulse_images.csv
pulse_groups Removed https://d2ssegy8jiabys.cloudfront.net/pulse_groups.csv
pulse_sources Removed https://d2ssegy8jiabys.cloudfront.net/pulse_sources.csv
pulse_urls Removed https://d2ssegy8jiabys.cloudfront.net/pulse_urls.csv
pulses Removed https://d2ssegy8jiabys.cloudfront.net/pulses.csv
rates Removed
review_videos Removed
reviews Removed
status Removed
time_to_beats Removed https://d2ssegy8jiabys.cloudfront.net/time_to_beats.csv
titles Removed https://d2ssegy8jiabys.cloudfront.net/titles.csv

Changed Fields

Object Endpoint Field Change
Game games popularity Removed
Game games pulse_count Removed
Game games time_to_beat Removed
Platform platforms product_family Renamed to platform_family
Search search popularity Removed

Web and Mobile Applications

What?

The IGDB V4 API uses Oauth App Tokens, which aren’t suitable for mobile or frontend-only applications:

To help transition to V4, we are providing a quick way to setup a proxy for mobile applications.

How?

Please follow our proxy guide!!

Endpoints

Age Rating

curl 'https://api.igdb.com/v4/age_ratings' \
-d 'fields category,checksum,content_descriptions,rating,rating_cover_url,synopsis;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/age_ratings",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields category,checksum,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.igdb.com/v4/age_ratings")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,content_descriptions,rating,rating_cover_url,synopsis;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/age_ratings".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,content_descriptions,rating,rating_cover_url,synopsis;").responseString()
let url = URL(string: "https://api.igdb.com/v4/age_ratings")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,content_descriptions,rating,rating_cover_url,synopsis;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/age_ratings'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,content_descriptions,rating,rating_cover_url,synopsis;'
puts http.request(request).body

Age Rating according to various rating organisations

Request Path

https://api.igdb.com/v4/age_ratings

field type description
category Category Enum The organization that has issued a specific rating
checksum uuid Hash of the object
content_descriptions Array of Age Rating Content Description IDs
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.igdb.com/v4/age_rating_content_descriptions' \
-d 'fields category,checksum,description;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/age_rating_content_descriptions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields category,checksum,description;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/age_rating_content_descriptions")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,description;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/age_rating_content_descriptions".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,description;").responseString()
let url = URL(string: "https://api.igdb.com/v4/age_rating_content_descriptions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,description;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/age_rating_content_descriptions'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,description;'
puts http.request(request).body

The organisation behind a specific rating

Request Path

https://api.igdb.com/v4/age_rating_content_descriptions

field type description
category Category Enum
checksum uuid Hash of the object
description String

Age Rating Content Description Enums

category

name value
PEGI 1
ESRB 2

Alternative Name

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

Alternative and international game titles

Request Path

https://api.igdb.com/v4/alternative_names

field type description
checksum uuid Hash of the object
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.igdb.com/v4/artworks' \
-d 'fields alpha_channel,animated,checksum,game,height,image_id,url,width;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/artworks",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields alpha_channel,animated,checksum,game,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/artworks")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,checksum,game,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/artworks".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields alpha_channel,animated,checksum,game,height,image_id,url,width;").responseString()
let url = URL(string: "https://api.igdb.com/v4/artworks")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,checksum,game,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/artworks'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields alpha_channel,animated,checksum,game,height,image_id,url,width;'
puts http.request(request).body

official artworks (resolution and aspect ratio may vary)

Request Path

https://api.igdb.com/v4/artworks

field type description
alpha_channel boolean
animated boolean
checksum uuid Hash of the object
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.igdb.com/v4/characters' \
-d 'fields akas,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/characters",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields akas,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/characters")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields akas,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/characters".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields akas,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/characters")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields akas,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/characters'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields akas,checksum,country_name,created_at,description,games,gender,mug_shot,name,slug,species,updated_at,url;'
puts http.request(request).body

Video game characters

Request Path

https://api.igdb.com/v4/characters

field type description
akas Array of Strings Alternative names for a character
checksum uuid Hash of the object
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 depicting a character
name String
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 0
Female 1
Other 2

species

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

Character Mug Shot

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

Images depicting game characters

Request Path

https://api.igdb.com/v4/character_mug_shots

field type description
alpha_channel boolean
animated boolean
checksum uuid Hash of the object
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.igdb.com/v4/collections' \
-d 'fields checksum,created_at,games,name,slug,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/collections",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/collections")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,games,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/collections".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,games,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/collections")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,games,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/collections'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,games,name,slug,updated_at,url;'
puts http.request(request).body

Collection, AKA Series

Request Path

https://api.igdb.com/v4/collections

field type description
checksum uuid Hash of the object
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.igdb.com/v4/companies' \
-d 'fields change_date,change_date_category,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/companies",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields change_date,change_date_category,changed_company_id,checksum,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.igdb.com/v4/companies")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields change_date,change_date_category,changed_company_id,checksum,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.igdb.com/v4/companies".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields change_date,change_date_category,changed_company_id,checksum,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.igdb.com/v4/companies")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields change_date,change_date_category,changed_company_id,checksum,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("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/companies'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields change_date,change_date_category,changed_company_id,checksum,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.igdb.com/v4/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
checksum uuid Hash of the object
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 Array of Game IDs 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 Array of Game IDs 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 Array of Company Website IDs The companies official websites

Company Enums

change_date_category

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

start_date_category

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

The logos of developers and publishers

Request Path

https://api.igdb.com/v4/company_logos

field type description
alpha_channel boolean
animated boolean
checksum uuid Hash of the object
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.igdb.com/v4/company_websites' \
-d 'fields category,checksum,trusted,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/company_websites",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields category,checksum,trusted,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/company_websites")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,trusted,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/company_websites".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,trusted,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/company_websites")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,trusted,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/company_websites'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,trusted,url;'
puts http.request(request).body

Company Website

Request Path

https://api.igdb.com/v4/company_websites

field type description
category Category Enum The service this website links to
checksum uuid Hash of the object
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
itch 15
epicgames 16
gog 17
discord 18

Cover

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

The cover art of games

Request Path

https://api.igdb.com/v4/covers

field type description
alpha_channel boolean
animated boolean
checksum uuid Hash of the object
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.igdb.com/v4/external_games' \
-d 'fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/external_games",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/external_games")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/external_games".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;").responseString()
let url = URL(string: "https://api.igdb.com/v4/external_games")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/external_games'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;'
puts http.request(request).body

Game IDs on other services

Request Path

https://api.igdb.com/v4/external_games

field type description
category Category Enum The id of the other service
checksum uuid Hash of the object
countries Array of Integers The ISO country code of the external game product.
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
media Media Enum The media of the external game.
name String The name of the game according to the other service
platform Reference ID for Platform The platform of the external game product.
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

media

name value
digital 1
physical 2

Franchise

curl 'https://api.igdb.com/v4/franchises' \
-d 'fields checksum,created_at,games,name,slug,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/franchises",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/franchises")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,games,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/franchises".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,games,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/franchises")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,games,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/franchises'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,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.igdb.com/v4/franchises

field type description
checksum uuid Hash of the object
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.igdb.com/v4/games' \
-d 'fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,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,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/games",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,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,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,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.igdb.com/v4/games")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,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,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/games".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,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,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;").responseString()
let url = URL(string: "https://api.igdb.com/v4/games")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,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,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/games'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,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,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,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.igdb.com/v4/games

field type description
age_ratings Array of Age Rating IDs 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 Array of Game IDs The bundles this game is a part of
category Category Enum The category of this game
checksum uuid Hash of the object
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 Array of Game IDs DLCs for this game
expansions Array of Game IDs 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
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 Array of Game IDs Similar games
slug String A url-safe, unique, lower-case version of the name
standalone_expansions Array of Game IDs 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
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 Array of Game Video IDs Videos of this game
websites Array of Website IDs Websites associated with this game

Game Enums

category

name value
main_game 0
dlc_addon 1
expansion 2
bundle 3
standalone_expansion 4
mod 5
episode 6
season 7

status

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

Game Engine

curl 'https://api.igdb.com/v4/game_engines' \
-d 'fields checksum,companies,created_at,description,logo,name,platforms,slug,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/game_engines",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/game_engines")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,companies,created_at,description,logo,name,platforms,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/game_engines".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,companies,created_at,description,logo,name,platforms,slug,updated_at,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/game_engines")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,companies,created_at,description,logo,name,platforms,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/game_engines'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,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.igdb.com/v4/game_engines

field type description
checksum uuid Hash of the object
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.igdb.com/v4/game_engine_logos' \
-d 'fields alpha_channel,animated,checksum,height,image_id,url,width;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/game_engine_logos",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields alpha_channel,animated,checksum,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/game_engine_logos")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,checksum,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/game_engine_logos".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields alpha_channel,animated,checksum,height,image_id,url,width;").responseString()
let url = URL(string: "https://api.igdb.com/v4/game_engine_logos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,checksum,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/game_engine_logos'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields alpha_channel,animated,checksum,height,image_id,url,width;'
puts http.request(request).body

The logos of game engines

Request Path

https://api.igdb.com/v4/game_engine_logos

field type description
alpha_channel boolean
animated boolean
checksum uuid Hash of the object
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 Mode

curl 'https://api.igdb.com/v4/game_modes' \
-d 'fields checksum,created_at,name,slug,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/game_modes",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/game_modes")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/game_modes".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/game_modes")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/game_modes'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,name,slug,updated_at,url;'
puts http.request(request).body

Single player, Multiplayer etc

Request Path

https://api.igdb.com/v4/game_modes

field type description
checksum uuid Hash of the object
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

curl 'https://api.igdb.com/v4/game_versions' \
-d 'fields checksum,created_at,features,game,games,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/game_versions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/game_versions")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,features,game,games,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/game_versions".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,features,game,games,updated_at,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/game_versions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,features,game,games,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/game_versions'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,features,game,games,updated_at,url;'
puts http.request(request).body

Details about game editions and versions.

Request Path

https://api.igdb.com/v4/game_versions

field type description
checksum uuid Hash of the object
created_at Unix Time Stamp Date this was initially added to the IGDB database
features Array of Game Version Feature IDs 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 Version Feature

curl 'https://api.igdb.com/v4/game_version_features' \
-d 'fields category,checksum,description,position,title,values;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/game_version_features",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields category,checksum,description,position,title,values;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/game_version_features")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,description,position,title,values;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/game_version_features".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,description,position,title,values;").responseString()
let url = URL(string: "https://api.igdb.com/v4/game_version_features")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,description,position,title,values;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/game_version_features'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,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.igdb.com/v4/game_version_features

field type description
category Category Enum The category of the feature description
checksum uuid Hash of the object
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 Array of Game Version Feature Value IDs 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.igdb.com/v4/game_version_feature_values' \
-d 'fields checksum,game,game_feature,included_feature,note;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/game_version_feature_values",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,game,game_feature,included_feature,note;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/game_version_feature_values")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,game,game_feature,included_feature,note;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/game_version_feature_values".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,game,game_feature,included_feature,note;").responseString()
let url = URL(string: "https://api.igdb.com/v4/game_version_feature_values")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,game,game_feature,included_feature,note;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/game_version_feature_values'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,game,game_feature,included_feature,note;'
puts http.request(request).body

The bool/text value of the feature

Request Path

https://api.igdb.com/v4/game_version_feature_values

field type description
checksum uuid Hash of the object
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.igdb.com/v4/game_videos' \
-d 'fields checksum,game,name,video_id;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/game_videos",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,game,name,video_id;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/game_videos")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,game,name,video_id;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/game_videos".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,game,name,video_id;").responseString()
let url = URL(string: "https://api.igdb.com/v4/game_videos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,game,name,video_id;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/game_videos'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,game,name,video_id;'
puts http.request(request).body

A video associated with a game

Request Path

https://api.igdb.com/v4/game_videos

field type description
checksum uuid Hash of the object
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.igdb.com/v4/genres' \
-d 'fields checksum,created_at,name,slug,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/genres",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/genres")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/genres".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/genres")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/genres'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,name,slug,updated_at,url;'
puts http.request(request).body

Genres of video game

Request Path

https://api.igdb.com/v4/genres

field type description
checksum uuid Hash of the object
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.igdb.com/v4/involved_companies' \
-d 'fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/involved_companies",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/involved_companies")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/involved_companies".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;").responseString()
let url = URL(string: "https://api.igdb.com/v4/involved_companies")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/involved_companies'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,company,created_at,developer,game,porting,publisher,supporting,updated_at;'
puts http.request(request).body

Request Path

https://api.igdb.com/v4/involved_companies

field type description
checksum uuid Hash of the object
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.igdb.com/v4/keywords' \
-d 'fields checksum,created_at,name,slug,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/keywords",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/keywords")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/keywords".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/keywords")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/keywords'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,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.igdb.com/v4/keywords

field type description
checksum uuid Hash of the object
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.igdb.com/v4/multiplayer_modes' \
-d 'fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/multiplayer_modes",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields campaigncoop,checksum,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.igdb.com/v4/multiplayer_modes")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/multiplayer_modes".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;").responseString()
let url = URL(string: "https://api.igdb.com/v4/multiplayer_modes")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/multiplayer_modes'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields campaigncoop,checksum,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.igdb.com/v4/multiplayer_modes

field type description
campaigncoop boolean True if the game supports campaign coop
checksum uuid Hash of the object
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

Platform

curl 'https://api.igdb.com/v4/platforms' \
-d 'fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/platforms",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,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.igdb.com/v4/platforms")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/platforms".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;").responseString()
let url = URL(string: "https://api.igdb.com/v4/platforms")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/platforms'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,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.igdb.com/v4/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
checksum uuid Hash of the object
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_family Reference ID for Platform Family The family of platforms this one belongs to
platform_logo Reference ID for Platform Logo The logo of the first Version of this platform
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 Array of Platform Version IDs Associated versions of this platform
websites Array of Platform Website IDs The main website

Platform Enums

category

name value
console 1
arcade 2
platform 3
operating_system 4
portable_console 5
computer 6

Platform Family

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

A collection of closely related platforms

Request Path

https://api.igdb.com/v4/platform_families

field type description
checksum uuid Hash of the object
name String The name of the platform family
slug String A url-safe, unique, lower-case version of the name
curl 'https://api.igdb.com/v4/platform_logos' \
-d 'fields alpha_channel,animated,checksum,height,image_id,url,width;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/platform_logos",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields alpha_channel,animated,checksum,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/platform_logos")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,checksum,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/platform_logos".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields alpha_channel,animated,checksum,height,image_id,url,width;").responseString()
let url = URL(string: "https://api.igdb.com/v4/platform_logos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,checksum,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/platform_logos'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields alpha_channel,animated,checksum,height,image_id,url,width;'
puts http.request(request).body

Logo for a platform

Request Path

https://api.igdb.com/v4/platform_logos

field type description
alpha_channel boolean
animated boolean
checksum uuid Hash of the object
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.igdb.com/v4/platform_versions' \
-d 'fields checksum,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 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/platform_versions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/platform_versions")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,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.igdb.com/v4/platform_versions".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,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.igdb.com/v4/platform_versions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,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("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/platform_versions'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,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.igdb.com/v4/platform_versions

field type description
checksum uuid Hash of the object
companies Array of Platform Version Company IDs 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.igdb.com/v4/platform_version_companies' \
-d 'fields checksum,comment,company,developer,manufacturer;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/platform_version_companies",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,comment,company,developer,manufacturer;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/platform_version_companies")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,comment,company,developer,manufacturer;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/platform_version_companies".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,comment,company,developer,manufacturer;").responseString()
let url = URL(string: "https://api.igdb.com/v4/platform_version_companies")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,comment,company,developer,manufacturer;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/platform_version_companies'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,comment,company,developer,manufacturer;'
puts http.request(request).body

A platform developer

Request Path

https://api.igdb.com/v4/platform_version_companies

field type description
checksum uuid Hash of the object
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.igdb.com/v4/platform_version_release_dates' \
-d 'fields category,checksum,created_at,date,human,m,platform_version,region,updated_at,y;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/platform_version_release_dates",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields category,checksum,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.igdb.com/v4/platform_version_release_dates")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,created_at,date,human,m,platform_version,region,updated_at,y;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/platform_version_release_dates".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,created_at,date,human,m,platform_version,region,updated_at,y;").responseString()
let url = URL(string: "https://api.igdb.com/v4/platform_version_release_dates")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,created_at,date,human,m,platform_version,region,updated_at,y;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/platform_version_release_dates'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,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.igdb.com/v4/platform_version_release_dates

field type description
category Category Enum The format of the release date
checksum uuid Hash of the object
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.igdb.com/v4/platform_websites' \
-d 'fields category,checksum,trusted,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/platform_websites",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields category,checksum,trusted,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/platform_websites")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,trusted,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/platform_websites".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,trusted,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/platform_websites")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,trusted,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/platform_websites'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,trusted,url;'
puts http.request(request).body

The main website for the platform

Request Path

https://api.igdb.com/v4/platform_websites

field type description
category Category Enum The service this website links to
checksum uuid Hash of the object
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.igdb.com/v4/player_perspectives' \
-d 'fields checksum,created_at,name,slug,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/player_perspectives",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/player_perspectives")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/player_perspectives".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/player_perspectives")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/player_perspectives'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,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.igdb.com/v4/player_perspectives

field type description
checksum uuid Hash of the object
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

Release Date

curl 'https://api.igdb.com/v4/release_dates' \
-d 'fields category,checksum,created_at,date,game,human,m,platform,region,updated_at,y;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/release_dates",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields category,checksum,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.igdb.com/v4/release_dates")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields category,checksum,created_at,date,game,human,m,platform,region,updated_at,y;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/release_dates".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields category,checksum,created_at,date,game,human,m,platform,region,updated_at,y;").responseString()
let url = URL(string: "https://api.igdb.com/v4/release_dates")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,checksum,created_at,date,game,human,m,platform,region,updated_at,y;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/release_dates'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields category,checksum,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.igdb.com/v4/release_dates

field type description
category Category Enum The format category of the release date
checksum uuid Hash of the object
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.igdb.com/v4/screenshots' \
-d 'fields alpha_channel,animated,checksum,game,height,image_id,url,width;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/screenshots",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields alpha_channel,animated,checksum,game,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/screenshots")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,checksum,game,height,image_id,url,width;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/screenshots".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields alpha_channel,animated,checksum,game,height,image_id,url,width;").responseString()
let url = URL(string: "https://api.igdb.com/v4/screenshots")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,checksum,game,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/screenshots'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields alpha_channel,animated,checksum,game,height,image_id,url,width;'
puts http.request(request).body

Screenshots of games

Request Path

https://api.igdb.com/v4/screenshots

field type description
alpha_channel boolean
animated boolean
checksum uuid Hash of the object
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.igdb.com/v4/search' \
-d 'fields alternative_name,character,checksum,collection,company,description,game,name,platform,published_at,test_dummy,theme;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/search",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields alternative_name,character,checksum,collection,company,description,game,name,platform,published_at,test_dummy,theme;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });
HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api.igdb.com/v4/search")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields alternative_name,character,checksum,collection,company,description,game,name,platform,published_at,test_dummy,theme;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/search".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields alternative_name,character,checksum,collection,company,description,game,name,platform,published_at,test_dummy,theme;").responseString()
let url = URL(string: "https://api.igdb.com/v4/search")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alternative_name,character,checksum,collection,company,description,game,name,platform,published_at,test_dummy,theme;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/search'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields alternative_name,character,checksum,collection,company,description,game,name,platform,published_at,test_dummy,theme;'
puts http.request(request).body

Request Path

https://api.igdb.com/v4/search

field type description
alternative_name String
character Reference ID for Character
checksum uuid Hash of the object
collection Reference ID for Collection
company Reference ID for Company
description String
game Reference ID for Game
name String
platform Reference ID for Platform
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.igdb.com/v4/themes' \
-d 'fields checksum,created_at,name,slug,updated_at,url;' \
-H 'Client-ID: Client ID' \
-H 'Authorization: Bearer access_token' \
-H 'Accept: application/json'
axios({
  url: "https://api.igdb.com/v4/themes",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'Client-ID: Client ID',
      'Authorization: Bearer access_token',
  },
  data: "fields checksum,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.igdb.com/v4/themes")
  .header("Client-ID", "Client ID")
  .header("Authorization", "Bearer access_token")
  .header("Accept", "application/json")
  .body("fields checksum,created_at,name,slug,updated_at,url;")
  .asJson();
val (request, response, result) = "https://api.igdb.com/v4/themes".httpPost()
  .header("Client-ID" to "Client ID", "Authorization" to "Bearer access_token", "Accept" to "application/json")
  .body("fields checksum,created_at,name,slug,updated_at,url;").responseString()
let url = URL(string: "https://api.igdb.com/v4/themes")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields checksum,created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("Client ID", forHTTPHeaderField: "Client-ID")
requestHeader.setValue("Bearer access_token", forHTTPHeaderField: "Authorization")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()
require 'net/https'
http = Net::HTTP.new('api.igdb.com/v4',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api.igdb.com/v4/themes'), {'Client-ID' => 'Client ID', 'Authorization' => 'Bearer access_token'})
request.body = 'fields checksum,created_at,name,slug,updated_at,url;'
puts http.request(request).body

Video game themes

Request Path

https://api.igdb.com/v4/themes

field type description
checksum uuid Hash of the object
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

Website

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

A website url, usually associated with a game

Request Path

https://api.igdb.com/v4/websites

field type description
category Category Enum The service this website links to
checksum uuid Hash of the object
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
itch 15
epicgames 16
gog 17
discord 18

Reference

CORS

What is CORS?

If you intend to use our API from your website you will encounter an issue with security; namely CORS Cross-Origin Resource Sharing.

There are security mechanisms in place by all major browsers to stop websites from accessing other domains without getting explicit permission. This is done through HTTP headers. So, for example, amazinggameswebsite.com cannot access api.igdb.com without us explicitly stating in the HTTP headers (Access-Control-Allow-Origin) that they have permission.

We do not offer the configuration of these headers as a service, so any browser-based javascript and mobile javascript frameworks like Ionic will not be able to communicate directly with the IGDB API.

Workaround

Please follow our proxy guide!!

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"
    }
]

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 rating

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

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:

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 value you can set for limit is 500.

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

Protocol Buffers

Google Protocol Buffers is a language neutral method for serializing structured data.
The IGDB API supports responses in this format so you do not have to write your own serialization libraries, but instead you could just generate one.
Since this is langage neutral it is supported by a variatey of languages.

How?

Generate the objects in your language of choise with our own 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.
The protobuf file is created in accordance with the proto3 specification

There are plenty of examples on how to do this Online and on the Protobuf Site.

Where?

To start recieving protobuf compatible responses from then api all you need to do is add .pb at the end of your request:
https://api.igdb.com/v4/games.pb
Then use your generated files to parse the response into the expected object.

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 games 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
keywordTypeID: 2 # The keyword's type ID from the table above/
keywordID: 148 # The ID of the 'moba' keyword
tagNumber: keywordTypeID << 28 # Bit-shifting the keywords's type ID by 28 bits, ensuring that it will get into the first four bits. The result will be 536870912
tagNumber |= keywordID # Adding the keyword ID to the tag number with a bitwise OR operation. The result will be 536871060.

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.igdb.com/v4/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.igdb.com/v4/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("Client-ID" to "Client ID", "Authorization" to "access_token").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_CLIENT_ID, // 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 rating asc;

f *;
s rating 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

Proxy

Why would I want a proxy?

There a number of reasons why you may wish to proxy requests to the IGDB API

How do I set up a proxy?

Proxies can be complex, but to get you started, we have a simple guide to get you up and running through AWS.

With a single link, you can boot up an AWS API Gateway in your own AWS account that will serve as a proxy.

API Gateway has a very generous free-tier, and pretty cheap after that. Please use the pricing calculator to gauge how much this will cost you before setting up the stack.

  1. First click this link
  2. Agree to the conditions and fill in your Twitch Credentials
  3. Click Next
  4. Configure Stack Options - Nothing is required here, you can click Next
  5. Verify settings, click the checkbox at the bottom, then click “Create stack”
  6. You’ll see the “Stack Details” screen, you’ll want to hit the refresh arrow on the right until your stack name on the left says “UPDATE_COMPLETE”
  7. Click “Outputs” tab to get the URL to your new proxy
  8. You can now post requests to your URL and it will proxy to our API

Important Note: the url generated will end in production, so you will want to post to https://<your-api-gateway-unique-id>.execute-api.us-west-2.amazonaws.com/production/v4/games.

What’s next?

API Gateway can do a lot


Support

Discord

Have a question?

If you have any questions about the API we recommend that you join our Discord, there you can discuss the API with other people working with it as well as the developers of the API and ask questions.

Reporting a bug

If you would like to report a bug you can do so in a Discord as well.


License

License

Any code examples or snippets found under api-docs.igdb.com are made available under the Twitch Developer Services Agreement as Program Materials.