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/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/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/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/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/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

curl 'https://api-v3.igdb.com/game_version_feature_values' \
-d 'fields game,game_feature,included_feature,note;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

curl 'https://api-v3.igdb.com/involved_companies' \
-d 'fields company,created_at,developer,game,porting,publisher,supporting,updated_at;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

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

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/involved_companies")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields company,created_at,developer,game,porting,publisher,supporting,updated_at;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/involved_companies".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields company,created_at,developer,game,porting,publisher,supporting,updated_at;").responseString()

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

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/involved_companies'), {'user-key' => YOUR_KEY})
request.body = 'fields company,created_at,developer,game,porting,publisher,supporting,updated_at;'
puts http.request(request).body

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

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

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

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

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

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

curl 'https://api-v3.igdb.com/multiplayer_modes' \
-d 'fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/multiplayer_modes",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/multiplayer_modes")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/multiplayer_modes".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;").responseString()

let url = URL(string: "https://api-v3.igdb.com/multiplayer_modes")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/multiplayer_modes'), {'user-key' => YOUR_KEY})
request.body = 'fields campaigncoop,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/pages' \
-d 'fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/pages",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/pages")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/pages".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;").responseString()

let url = URL(string: "https://api-v3.igdb.com/pages")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/pages'), {'user-key' => YOUR_KEY})
request.body = 'fields background,battlenet,category,color,company,country,created_at,description,feed,game,name,origin,page_follows_count,page_logo,slug,sub_category,updated_at,uplay,url,user,websites;'
puts http.request(request).body

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

curl 'https://api-v3.igdb.com/platforms' \
-d 'fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/platforms",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/platforms")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/platforms".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;").responseString()

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

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/platforms'), {'user-key' => YOUR_KEY})
request.body = 'fields abbreviation,alternative_name,category,created_at,generation,name,platform_logo,product_family,slug,summary,updated_at,url,versions,websites;'
puts http.request(request).body

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

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

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

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

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

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

curl 'https://api-v3.igdb.com/platform_versions' \
-d 'fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/platform_versions",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/platform_versions")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/platform_versions".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;").responseString()

let url = URL(string: "https://api-v3.igdb.com/platform_versions")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/platform_versions'), {'user-key' => YOUR_KEY})
request.body = 'fields companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;'
puts http.request(request).body

curl 'https://api-v3.igdb.com/platform_version_companies' \
-d 'fields comment,company,developer,manufacturer;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

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

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

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

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

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

curl 'https://api-v3.igdb.com/platform_version_release_dates' \
-d 'fields category,created_at,date,human,m,platform_version,region,updated_at,y;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/platform_version_release_dates",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields category,created_at,date,human,m,platform_version,region,updated_at,y;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/platform_version_release_dates")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields category,created_at,date,human,m,platform_version,region,updated_at,y;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/platform_version_release_dates".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields category,created_at,date,human,m,platform_version,region,updated_at,y;").responseString()

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

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/platform_version_release_dates'), {'user-key' => YOUR_KEY})
request.body = 'fields category,created_at,date,human,m,platform_version,region,updated_at,y;'
puts http.request(request).body

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

curl 'https://api-v3.igdb.com/pulses' \
-d 'fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;' \
-H 'user-key: API_KEY' \
-H 'Accept: application/json'

axios({
  url: "https://api-v3.igdb.com/pulses",
  method: 'POST',
  headers: {
      'Accept': 'application/json',
      'user-key': API_KEY
  },
  data: "fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;"
})
  .then(response => {
      console.log(response.data);
  })
  .catch(err => {
      console.error(err);
  });

HttpResponse<JsonNode> jsonResponse = Unirest.post("https://api-v3.igdb.com/pulses")
  .header("user-key", API_KEY)
  .header("Accept", "application/json")
  .body("fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;")
  .asJson();

val (request, response, result) = "https://api-v3.igdb.com/pulses".httpPost()
  .header("user-key" to "YOUR_API_KEY", "Accept" to "application/json")
  .body("fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;").responseString()

let url = URL(string: "https://api-v3.igdb.com/pulses")!
var requestHeader = URLRequest.init(url: url as! URL)
requestHeader.httpBody = "fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;".data(using: .utf8, allowLossyConversion: false)
requestHeader.httpMethod = "POST"
requestHeader.setValue("YOUR_API_KEY", forHTTPHeaderField: "user-key")
requestHeader.setValue("application/json", forHTTPHeaderField: "Accept")
URLSession.shared.dataTask(with: requestHeader) { data, response, error in }.resume()

require 'net/https'
http = Net::HTTP.new('api-v3.igdb.com',443)
http.use_ssl = true
request = Net::HTTP::Post.new(URI('https://api-v3.igdb.com/pulses'), {'user-key' => YOUR_KEY})
request.body = 'fields author,category,created_at,ignored,image,published_at,pulse_image,pulse_source,summary,tags,title,uid,updated_at,videos,website;'
puts http.request(request).body