curl 'https://api-v3.igdb.com/achievements' \
-d 'fields achievement_icon,category,created_at,description,external_id,game,language,locked_achievement_icon,name,owners,owners_percentage,rank,slug,tags,updated_at;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/achievements",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields achievement_icon,category,created_at,description,external_id,game,language,locked_achievement_icon,name,owners,owners_percentage,rank,slug,tags,updated_at;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/achievements")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields achievement_icon,category,created_at,description,external_id,game,language,locked_achievement_icon,name,owners,owners_percentage,rank,slug,tags,updated_at;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/achievements".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields achievement_icon,category,created_at,description,external_id,game,language,locked_achievement_icon,name,owners,owners_percentage,rank,slug,tags,updated_at;").responseString()

let url = URL(string: "https://api-v3.igdb.com/achievements")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields achievement_icon,category,created_at,description,external_id,game,language,locked_achievement_icon,name,owners,owners_percentage,rank,slug,tags,updated_at;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/achievements'), {'user-key' => YOUR_KEY})
request.body = 'fields achievement_icon,category,created_at,description,external_id,game,language,locked_achievement_icon,name,owners,owners_percentage,rank,slug,tags,updated_at;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/achievement_icons' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/achievement_icons",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/achievement_icons")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/achievement_icons".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()

let url = URL(string: "https://api-v3.igdb.com/achievement_icons")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/achievement_icons'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/age_ratings' \
-d 'fields category,content_descriptions,rating,rating_cover_url,synopsis;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/age_ratings",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,content_descriptions,rating,rating_cover_url,synopsis;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/age_ratings")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,content_descriptions,rating,rating_cover_url,synopsis;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/age_ratings".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,content_descriptions,rating,rating_cover_url,synopsis;").responseString()

let url = URL(string: "https://api-v3.igdb.com/age_ratings")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,content_descriptions,rating,rating_cover_url,synopsis;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/age_ratings'), {'user-key' => YOUR_KEY})
request.body = 'fields category,content_descriptions,rating,rating_cover_url,synopsis;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/age_rating_content_descriptions' \
-d 'fields category,description;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/age_rating_content_descriptions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,description;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/age_rating_content_descriptions")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,description;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/age_rating_content_descriptions".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,description;").responseString()

let url = URL(string: "https://api-v3.igdb.com/age_rating_content_descriptions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,description;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/age_rating_content_descriptions'), {'user-key' => YOUR_KEY})
request.body = 'fields category,description;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/alternative_names' \
-d 'fields comment,game,name;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/alternative_names",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields comment,game,name;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/alternative_names")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields comment,game,name;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/alternative_names".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields comment,game,name;").responseString()

let url = URL(string: "https://api-v3.igdb.com/alternative_names")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields comment,game,name;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/alternative_names'), {'user-key' => YOUR_KEY})
request.body = 'fields comment,game,name;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/artworks' \
-d 'fields alpha_channel,animated,game,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/artworks",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,game,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/artworks")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,game,height,image_id,url,width;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/artworks".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,game,height,image_id,url,width;").responseString()

let url = URL(string: "https://api-v3.igdb.com/artworks")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,game,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/artworks'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,game,height,image_id,url,width;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/characters' \
-d 'fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/characters",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/characters")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/characters".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;").responseString()

let url = URL(string: "https://api-v3.igdb.com/characters")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/characters'), {'user-key' => YOUR_KEY})
request.body = 'fields akas,country_name,created_at,description,games,gender,mug_shot,name,people,slug,species,updated_at,url;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/collections' \
-d 'fields created_at,games,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/collections",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,games,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/collections")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,games,name,slug,updated_at,url;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/collections".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,games,name,slug,updated_at,url;").responseString()

let url = URL(string: "https://api-v3.igdb.com/collections")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,games,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/collections'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,games,name,slug,updated_at,url;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/character_mug_shots' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/character_mug_shots",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/character_mug_shots")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/character_mug_shots".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()

let url = URL(string: "https://api-v3.igdb.com/character_mug_shots")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/character_mug_shots'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/company_logos' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/company_logos",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/company_logos")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/company_logos".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()

let url = URL(string: "https://api-v3.igdb.com/company_logos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/company_logos'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/company_websites' \
-d 'fields category,trusted,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/company_websites",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,trusted,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/company_websites")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,trusted,url;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/company_websites".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,trusted,url;").responseString()

let url = URL(string: "https://api-v3.igdb.com/company_websites")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,trusted,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/company_websites'), {'user-key' => YOUR_KEY})
request.body = 'fields category,trusted,url;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/companies' \
-d 'fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/companies",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/companies")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/companies".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;").responseString()

let url = URL(string: "https://api-v3.igdb.com/companies")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/companies'), {'user-key' => YOUR_KEY})
request.body = 'fields change_date,change_date_category,changed_company_id,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/covers' \
-d 'fields alpha_channel,animated,game,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/covers",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,game,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/covers")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,game,height,image_id,url,width;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/covers".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,game,height,image_id,url,width;").responseString()

let url = URL(string: "https://api-v3.igdb.com/covers")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,game,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/covers'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,game,height,image_id,url,width;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/external_games' \
-d 'fields category,created_at,game,name,uid,updated_at,url,year;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/external_games",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,created_at,game,name,uid,updated_at,url,year;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/external_games")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,created_at,game,name,uid,updated_at,url,year;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/external_games".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,created_at,game,name,uid,updated_at,url,year;").responseString()

let url = URL(string: "https://api-v3.igdb.com/external_games")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,created_at,game,name,uid,updated_at,url,year;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/external_games'), {'user-key' => YOUR_KEY})
request.body = 'fields category,created_at,game,name,uid,updated_at,url,year;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/feeds' \
-d 'fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/feeds",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/feeds")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/feeds".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;").responseString()

let url = URL(string: "https://api-v3.igdb.com/feeds")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/feeds'), {'user-key' => YOUR_KEY})
request.body = 'fields category,content,created_at,feed_likes_count,feed_video,games,meta,published_at,pulse,slug,title,uid,updated_at,url,user;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/franchises' \
-d 'fields created_at,games,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/franchises",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,games,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/franchises")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,games,name,slug,updated_at,url;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/franchises".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,games,name,slug,updated_at,url;").responseString()

let url = URL(string: "https://api-v3.igdb.com/franchises")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,games,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/franchises'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,games,name,slug,updated_at,url;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/games' \
-d 'fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/games",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/games")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/games".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;").responseString()

let url = URL(string: "https://api-v3.igdb.com/games")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/games'), {'user-key' => YOUR_KEY})
request.body = 'fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,collection,cover,created_at,dlcs,expansions,external_games,first_release_date,follows,franchise,franchises,game_engines,game_modes,genres,hypes,involved_companies,keywords,multiplayer_modes,name,parent_game,platforms,player_perspectives,popularity,pulse_count,rating,rating_count,release_dates,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,time_to_beat,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/game_engines' \
-d 'fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/game_engines",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_engines")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/game_engines".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;").responseString()

let url = URL(string: "https://api-v3.igdb.com/game_engines")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/game_engines'), {'user-key' => YOUR_KEY})
request.body = 'fields companies,created_at,description,logo,name,platforms,slug,updated_at,url;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/game_engine_logos' \
-d 'fields alpha_channel,animated,height,image_id,url,width;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/game_engine_logos",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields alpha_channel,animated,height,image_id,url,width;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_engine_logos")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/game_engine_logos".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields alpha_channel,animated,height,image_id,url,width;").responseString()

let url = URL(string: "https://api-v3.igdb.com/game_engine_logos")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields alpha_channel,animated,height,image_id,url,width;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/game_engine_logos'), {'user-key' => YOUR_KEY})
request.body = 'fields alpha_channel,animated,height,image_id,url,width;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/game_modes' \
-d 'fields created_at,name,slug,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/game_modes",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,name,slug,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_modes")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,name,slug,updated_at,url;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/game_modes".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,name,slug,updated_at,url;").responseString()

let url = URL(string: "https://api-v3.igdb.com/game_modes")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,name,slug,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/game_modes'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,name,slug,updated_at,url;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/game_versions' \
-d 'fields created_at,features,game,games,updated_at,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/game_versions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields created_at,features,game,games,updated_at,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_versions")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields created_at,features,game,games,updated_at,url;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/game_versions".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields created_at,features,game,games,updated_at,url;").responseString()

let url = URL(string: "https://api-v3.igdb.com/game_versions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields created_at,features,game,games,updated_at,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/game_versions'), {'user-key' => YOUR_KEY})
request.body = 'fields created_at,features,game,games,updated_at,url;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/game_version_features' \
-d 'fields category,description,position,title,values;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/game_version_features",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,description,position,title,values;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/game_version_features")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,description,position,title,values;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/game_version_features".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,description,position,title,values;").responseString()

let url = URL(string: "https://api-v3.igdb.com/game_version_features")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields category,description,position,title,values;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/game_version_features'), {'user-key' => YOUR_KEY})
request.body = 'fields category,description,position,title,values;'
puts http.request(request).body