Games API

import { getGames, getGamesUniverseidVotes, postGamesUniverseidFavorites } from 'rozod/endpoints/gamesv1';
import { fetchApi } from 'rozod';

const games = await fetchApi(getGames, {
  universeIds: [1234567890, 9876543210],
  languageCode: 'en-us', // Optional
});

if (!isAnyErrorResponse(games)) {
  games.data.forEach((game) => {
    console.log(`${game.name} by ${game.creator.name}`);
    console.log(`Playing: ${game.playing} | Visits: ${game.visits}`);
  });
}

import { getGamesPlaceidServersServertype } from 'rozod/endpoints/gamesv1';

const servers = await fetchApi(getGamesPlaceidServersServertype, {
  placeId: 1234567890,
  serverType: 0, // 0 = Public, 1 = Friend
  limit: 25,
  sortOrder: 2, // 1 = Asc, 2 = Desc
});

if (!isAnyErrorResponse(servers)) {
  servers.data.forEach((server) => {
    console.log(`Server: ${server.id}`);
    console.log(`Players: ${server.playing}/${server.maxPlayers}`);
    console.log(`Ping: ${server.ping}ms`);
  });
}

import { postGamesUniverseidFavorites } from 'rozod/endpoints/gamesv1';

// Favorite a game
const result = await fetchApi(postGamesUniverseidFavorites, {
  universeId: 1234567890,
  body: {
    isFavorited: true,
  },
});

if (!isAnyErrorResponse(result)) {
  console.log('Game favorited successfully');
}

import { getGamesUniverseidFavoritesCount } from 'rozod/endpoints/gamesv1';

const favCount = await fetchApi(getGamesUniverseidFavoritesCount, {
  universeId: 1234567890,
});

if (!isAnyErrorResponse(favCount)) {
  console.log(`Favorites: ${favCount.favoritesCount}`);
}

import { getGamesUniverseidVotes, patchGamesUniverseidUserVotes } from 'rozod/endpoints/gamesv1';

// Get vote counts
const votes = await fetchApi(getGamesUniverseidVotes, {
  universeId: 1234567890,
});

if (!isAnyErrorResponse(votes)) {
  console.log(`👍 ${votes.upVotes} | 👎 ${votes.downVotes}`);
}

// Submit a vote
const voteResult = await fetchApi(patchGamesUniverseidUserVotes, {
  universeId: 1234567890,
  body: {
    vote: true, // true = upvote, false = downvote
  },
});

import { getGamesUniverseidMedia } from 'rozod/endpoints/gamesv1';

const media = await fetchApi(getGamesUniverseidMedia, {
  universeId: 1234567890,
});

if (!isAnyErrorResponse(media)) {
  media.data.forEach((item) => {
    console.log(`Type: ${item.assetType}`);
    if (item.imageId) {
      console.log(`Image ID: ${item.imageId}`);
    }
  });
}

import { getGamesMultigetPlaceDetails } from 'rozod/endpoints/gamesv1';

const places = await fetchApi(getGamesMultigetPlaceDetails, {
  placeIds: [1234567890, 9876543210],
});

if (!isAnyErrorResponse(places)) {
  places.forEach((place) => {
    console.log(`${place.name} - ${place.description}`);
    console.log(`Builder: ${place.builder}`);
    console.log(`Playable: ${place.isPlayable}`);
  });
}

import { getGamesPlaceidPrivateServers } from 'rozod/endpoints/gamesv1';

const privateServers = await fetchApi(getGamesPlaceidPrivateServers, {
  placeId: 1234567890,
  limit: 10,
});

if (!isAnyErrorResponse(privateServers)) {
  privateServers.data.forEach((server) => {
    console.log(`${server.name} - ${server.owner?.displayName}`);
    console.log(`Code: ${server.accessCode}`);
  });
}

import { getPrivateServersEnabledInUniverseUniverseid } from 'rozod/endpoints/gamesv1';

const enabled = await fetchApi(getPrivateServersEnabledInUniverseUniverseid, {
  universeId: 1234567890,
});

if (!isAnyErrorResponse(enabled)) {
  console.log(`Private servers enabled: ${enabled.privateServersEnabled}`);
}

import { getPrivateServersMyPrivateServers } from 'rozod/endpoints/gamesv1';

const myServers = await fetchApi(getPrivateServersMyPrivateServers, {
  privateServersTab: 0, // 0 = Active, 1 = Inactive
  itemsPerPage: 25,
});

if (!isAnyErrorResponse(myServers)) {
  myServers.data.forEach((server) => {
    console.log(`${server.universeName}: ${server.name}`);
    console.log(`Expires: ${server.expirationDate}`);
  });
}

import { getGamesRecommendationsGameUniverseid } from 'rozod/endpoints/gamesv1';

const recommendations = await fetchApi(getGamesRecommendationsGameUniverseid, {
  universeId: 1234567890,
  MaxRows: 10,
  IsTruncatedResultsEnabled: false,
  PaginationKey: '',
});

if (!isAnyErrorResponse(recommendations)) {
  recommendations.games.forEach((game) => {
    console.log(`${game.name} - ${game.playerCount} playing`);
  });
}

import { getGamesVotes } from 'rozod/endpoints/gamesv1';

const votes = await fetchApi(getGamesVotes, {
  universeIds: [1234567890, 9876543210],
});

if (!isAnyErrorResponse(votes)) {
  votes.data.forEach((vote) => {
    console.log(`Game ${vote.id}: ${vote.upVotes} up, ${vote.downVotes} down`);
  });
}

import { getGamesGamesProductInfo } from 'rozod/endpoints/gamesv1';

const products = await fetchApi(getGamesGamesProductInfo, {
  universeIds: [1234567890],
});

if (!isAnyErrorResponse(products)) {
  products.data.forEach((product) => {
    console.log(`Price: ${product.price} Robux`);
    console.log(`For sale: ${product.isForSale}`);
  });
}