RealmsAPI

Definitions

Param	Type	Description
realmId	`string`	The ID of the Realm
realmInviteCode	`string`	The invite code for the Realm. This can be used an unlimited amount of times and allows anyone with the code to join the Realm (Only on Bedrock)
invitationId	`string`	The ID of the invitation. This can only be used by the player it is sent to and expires after use (Only on Bedrock)
username	`string`	The username of player
uuid	`string`	The unique ID of the player, without hyphens
xuid	`string`	The Xbox User ID of the targeted player
configuration	`string`	The array of configurations that can change gamerules and Realm features
slotId	`string`	The ID of one of the Realm world slots. This value can be either 1, 2, or 3
permission	`string`	The permission that can be added to a players. This can resolve to VISITOR, MEMBER, or OPERATOR

Options

Used for RealmAPI.from()

Param	Type	Description
usePreview	`Boolean`	If the Preview Realms API should be used (Only bedrock)

Constructor

const { Authflow } = require('prismarine-auth') 
const { RealmAPI } = require('prismarine-realms')

const authflow = new Authflow()

const api = RealmAPI.from(authflow, 'bedrock' | 'java', options)

Bedrock & Java

getRealms

() => Promise<Realm[]>

Returns a list of Realms the authenticating account has joined or owns.

await api.getRealms()

Output

Realm[]

getRealm

(realmId: string) => Promise<Realm>

Gets detailed information about a Realm if owned

await api.getRealm('1234567')

Output

Realm

getRealmBackups

(realmId: string, slotId: string) => Promise<Backup[]>

Gets a list of backups for a Realm

await api.getRealmBackups('1234567', '1')

Output

Backup[]

restoreRealmFromBackup

(realmId: string, slotId: string, backupId: string) => Promise<string>

Restores a Realm from a backup

await api.restoreRealmFromBackup('1234567', '1', '1970-01-01T00:00:00.000Z')

Either 'Retry again later' or 'true'. Always seems to return 'Retry again later' on the first try.

getRealmWorldDownload

(realmId: string, slotId: string, backupId?: string) => Promise<object>

Java will always return the latest state of the world

Gets the download for a Realm world. If no backup is specified or "latest" is specified, the latest state of the world is returned.

await api.getRealmWorldDownload('1234567', '1', '1970-01-01T00:00:00.000Z')

Output

Download

Bedrock Only

getRealmFromInvite

(realmInviteCode: string, invite: boolean) => Promise<Realm>

Gets detailed information about a Realm from the invite code and adds it to the authenticating accounts Realms list if not present. If invite is false, the Realm will not be added to the authenticating accounts Realms list.

await api.getRealmFromInvite('AB1CD2EFA3B') // https://realms.gg/AB1CD2EFA3B will work as well

Output

Realm

getRealmInvite

(realmId: string) => Promise<RealmInvite>

Gets the invite code for a Realm

await api.getRealmInvite('1234567')

Output

{
    inviteCode: string,
    ownerXUID: string,
    type: string,
    createdOn: number,
    inviteLink: string,
    deepLinkUrl: string,
}

refreshRealmInvite

(realmId: string) => Promise<RealmInvite>

Refreshes the invite code for a Realm (Note: This will invalidate the previous invite code)

await api.refreshRealmInvite('1234567')

Output

{
    inviteCode: string,
    ownerXUID: string,
    type: string,
    createdOn: number,
    inviteLink: string,
    deepLinkUrl: string,
}

getPendingInviteCount

() => Promise<number>

Gets the number of pending invites for the authenticating account

await api.getPendingInviteCount()

Output

number

getPendingInvites

() => Promise<RealmPlayerInvite[]>

Gets a list of pending invites for the authenticating account

await api.getPendingInvites()

Output

[
    {
        invitationId: string
        worldName: string
        worldDescription: string
        worldOwnerName: string
        worldOwnerXUID: string
        createdOn: number
    }
]

acceptRealmInvitation

(invitationId: string) => Promise<void>

Accepts a pending invite for the authenticating account

await api.acceptRealmInvitation('1234567')

Output

No output

acceptRealmInviteFromCode

(realmInviteCode: string) => Promise<Realm>

Accepts a Realm invite from an invite link or code.

await api.acceptRealmInviteFromCode('1234567')

Output

Realm

rejectRealmInvitation

(invitationId: string) => Promise<void>

Rejects a pending invite for the authenticating account

await api.rejectRealmInvitation('1234567')

Output

No output

removePlayerFromRealm

(realmId: string, xuid: string) => Promise<Realm>

Removes a player from the Realm

await api.removePlayerFromRealm('1234567', 'a8005260a332457097a50bdbe48a9a21')

Output

Realm

resetRealm

(realmId: string) => Promise<void>

Resets a Realm to its default, or brand new state

await api.resetRealm('1234567')

Output

No output

opRealmPlayer

(realmId: string, uuid: string) => Promise<Realm>

OPs a player on the Realm

await api.opRealmPlayer('1234567', 'a8005260a332457097a50bdbe48a9a21')

Output

Realm

deopRealmPlayer

(realmId: string, uuid: string) => Promise<Realm>

DEOPs a player on the Realm

await api.deopRealmPlayer('1234567', 'a8005260a332457097a50bdbe48a9a21')

Output

Realm

banPlayerFromRealm

(realmId: string, uuid: string) => Promise<void>

Bans a player from the Realm

await api.banPlayerFromRealm('1234567', 'a8005260a332457097a50bdbe48a9a21')

Output

No output

unbanPlayerFromRealm

(realmId: string, uuid: string) => Promise<void>

Unbans a player from the Realm

await api.unbanPlayerFromRealm('1234567', 'a8005260a332457097a50bdbe48a9a21')

Output

No output

removeRealmFromJoinedList

(realmId: string) => Promise<void>

Removes the Realm from your joined list

await api.removeRealmFromJoinedList('1234567')

Output

No output

changeIsTexturePackRequired

(realmId: string, forced: boolean) => Promise<void>

Changes if a texture pack is required to be applied when joining

await api.changeIsTexturePackRequired('1234567', true)

Output

No output

changeRealmDefaultPermission

(realmId: string, permission: string) => Promise<void>

Changes the Realms default permission. Permission can be VISITOR, MEMBER, or OPERATOR

await api.changeRealmDefaultPermission('1234567', 'MEMBER')

Output

No output

changeRealmPlayerPermission

(realmId: string, permission: string, uuid: string) => Promise<void>

Changes the a players permission. Permission can be VISITOR, MEMBER, or OPERATOR

await api.changeRealmPlayerPermission('1234567', 'MEMBER', 'a8005260a332457097a50bdbe48a9a21')

Output

No output

Structures

Realm

{
    getAddress(): Promise<Address>
    invitePlayer(uuid: string, name: string): Promise<Realm>
    open(): Promise<void>
    close(): Promise<void>
    getBackups(): Promise<Backup[]>
    getWorldDownload(): Promise<Download>
    id: number
    remoteSubscriptionId: string
    owner: string | null
    ownerUUID: string
    name: string
    motd: string
    defaultPermission: string
    state: string
    daysLeft: number
    expired: boolean
    expiredTrial: boolean
    gracePeriod: boolean
    worldType: string
    players: RealmPlayer[] | null
    maxPlayers: number
    minigameName: string
    minigameId: number
    minigameImage: string
    activeSlot: number
    slots: Slot[] | null
    member: boolean
    clubId: number
    subscriptionRefreshStatus: null
}

interface RealmPlayer {
    uuid: string,
    name: string,
    operator: boolean,
    accepted: boolean,
    online: boolean,
    permission: string
}

interface Slot {
    options: string
    slotId: number
}

getAddress

() => Promise<Address>

Gets the address for the Realm.

await realm.getAddress()

Output

{
    host: string
    port: number
}

invitePlayer

(uuid: string, name: string) => Promise<Realm>

Invites a player to the Realm. On Bedrock the UUID is the player's XUID.

await realm.invitePlayer('a8005260a332457097a50bdbe48a9a21', 'Steve')

Output

Realm

open

() => Promise<boolean>

Opens a Realm. Allows players to join

await realm.open()

True if the world has opened

close

() => Promise<boolean>

Closes a Realm. Removes all current players and restricts joining

await realm.close()

True if the world has closed

delete

() => Promise<void>

Deletes a Realm. This removes all worlds and the Realm itself beyond recovery

await realm.delete()

No output

getBackups

() => Promise<Backup[]>

Gets a list of backups for the Realm

await realm.getBackups()

Output

Backup[]

getWorldDownload

() => Promise<Download>

Gets the most recent download for the Realm's world

await realm.getWorldDownload()

Output

Download

getSubscriptionInfo

(detailed: boolean) => Promise<RealmSubscriptionInfo|RealmSubscriptionInfoDetailed>

Gets the subscription info of the Realm

await realm.getSubscriptionInfo(true)

Output

Basic Subscription Info:
{
  startDate: number
  daysLeft: number
  subscriptionType: string
}

Detailed Subscription Info:
{
  type: string
  store: string
  startDate: number
  endDate: number
  renewalPeriod: number
  daysLeft: number
  subscriptionId: string
}

changeActiveSlot

(realmId: string, slotId, number) => Promise<boolean>

Changes the active world slot. Slot ID can be 1, 2, or 3 (or 4 for Java Edition)

await realm.changeActiveSlot('1234567', 1)

Output

True if the active world is changed

changeNameAndDescription

(realmId: string, name: string, description: string) => Promise<void>

Changes the name and description of the Realm

await realm.changeNameAndDescription('1234567', 'Hello', 'World!')

Output

No output

Backup

{
    getDownload(): Promise<Download>
    restore(): Promise<void>
    id: string
    lastModifiedDate: number
    size: number
    metadata: {
        gameDifficulty: string
        name: string
        gameServerVersion: string
        enabledPacks: { 
          resourcePack: string
          behaviorPack: string
        }
        description: string | null
        gamemode: string
        worldType: string
    }
}

getDownload

() => Promise<Download>

Not available on Java

Gets the download information for the backup

await backup.getDownload()

Output

Buffer

restore

() => Promise<void>

Restores the Realm back to this backup

await backup.restore()

No output

Download

{
    writeToDirectory(directory: string): Promise<void>
    getBuffer(): Promise<Buffer>
    downloadUrl: string
    fileExtension: '.mcworld' | '.tar.gz'
    resourcePackUrl?: string // Java only
    resourcePackHash?: string // Java only
    size?: number // Bedrock only
    token?: string // Bedrock only
}

writeToDirectory

(directory: string) => Promise<void>

Downloads the world to the specified directory.

await download.writeToDirectory()

No output

getBuffer

() => Promise<Buffer>

Downloads the world and returns it as a Buffer

await download.getBuffer()

Output

Buffer

Files

API.md

Latest commit

History

API.md

File metadata and controls

RealmsAPI

Definitions

Table of Contents

Options

Constructor

Bedrock & Java

getRealms

getRealm

getRealmBackups

restoreRealmFromBackup

getRealmWorldDownload

Bedrock Only

getRealmFromInvite

getRealmInvite

refreshRealmInvite

getPendingInviteCount

getPendingInvites

acceptRealmInvitation

acceptRealmInviteFromCode

rejectRealmInvitation

removePlayerFromRealm

resetRealm

opRealmPlayer

deopRealmPlayer

banPlayerFromRealm

unbanPlayerFromRealm

removeRealmFromJoinedList

changeIsTexturePackRequired

changeRealmDefaultPermission

changeRealmPlayerPermission

Structures

Realm

getAddress

invitePlayer

open

close

delete

getBackups

getWorldDownload

getSubscriptionInfo

changeActiveSlot

changeNameAndDescription

Backup

getDownload

restore

Download

writeToDirectory

getBuffer