Satisfactory Dedicated Server HTTPS API Client

A low-level, zero dependency Node.js client library for the HTTPS API of the Satisfactory Dedicated Server.

Installation

npm i @djwoodz/satisfactory-dedicated-server-https-api-client

Example Usage

1// import module
2const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');

1// create apiClient
2const apiClient = new APIClient({
3  address: '127.0.0.1',
4  port: 7777,
5  https: {
6    request: {
7      rejectUnauthorized: false, // accepts any CA, not secure
8    },
9  },
10});

1// health check using await
2const { data } = await apiClient.healthCheck();
3console.log(data);

1// health check using .then()
2apiClient.healthCheck()
3  .then((data) => {
4    console.log(data);
5  });

APIClient Constructor Options

Name	Type	Default	Description
address	string	'127.0.0.1'	The address of the Dedicated Server
port	number	7777	The port number of the Dedicated Server
https	object	{ request: { timeout:30000 } }	Options for HTTPS functions
authenticationToken	string		The authentication token to be set for requests

APIClient Functions

API Functions

These map to the 'API Functions' in the DedicatedServerAPIDocs.md file (available under the 'CommunityResources' directory of the installed Satisfactory game):

Method Signature	Description
healthCheck(clientCustomData?: string) → {Promise.<*>}	Performs a health check on the server
verifyAuthenticationToken() → {Promise.<*>}	Verifies the authentication token currently set for the API Client
passwordlessLogin(minimumPrivilegeLevel: PrivilegeLevel) → {Promise.<*>}	Performs a passwordless login
passwordLogin(minimumPrivilegeLevel: PrivilegeLevel, password: string) → {Promise.<*>}	Performs a password-based login
queryServerState() → {Promise.<*>}	Queries the state of the server
getServerOptions() → {Promise.<*>}	Gets the options for the server
getAdvancedGameSettings() → {Promise.<*>}	Gets the advanced game settings for the server
applyAdvancedGameSettings(appliedAdvancedGameSettings: object) → {Promise.<*>}	Applies the provided advanced game settings to the server
claimServer(serverName: string, adminPassword: string) → {Promise.<*>}	Stakes a claim on the server
renameServer(serverName: string) → {Promise.<*>}	Renames the server
setClientPassword(password: string) → {Promise.<*>}	Sets the client password for the server
setAdminPassword(password: string) → {Promise.<*>}	Sets the admin password for the server
setAutoLoadSessionName(sessionName: string) → {Promise.<*>}	Sets the session name to automatically load when joining the server
runCommand(command: string) → {Promise.<*>}	Runs a command on the server
shutdown() → {Promise.<*>}	Requests the server to shut down
applyServerOptions(updatedServerOptions: object.<string, string>) → {Promise.<*>}	Applies new server options to the server
createNewGame(newGameData: object) → {Promise.<*>}	Creates a new game on the server
saveGame(saveName: string) → {Promise.<*>}	Saves the game on the server using the provided name
deleteSaveFile(saveName: string) → {Promise.<*>}	Deletes a save file from the server
deleteSaveSession(sessionName: string) → {Promise.<*>}	Deletes all save files from the server belonging to the given session name
enumerateSessions() → {Promise.<*>}	Enumerates all sessions on the server
loadGame(saveName: string, enableAdvancedGameSettings?: boolean) → {Promise.<*>}	Loads a save game with the given name from the server
uploadSaveGame(buffer: Buffer, saveName: string, loadSaveGame?: boolean, enableAdvancedGameSettings?: boolean) → {Promise.<*>}	Upload a save game file to the server using the given and name
downloadSaveGame(saveName: string) → {Promise.<Buffer>}	Downloads a save game with the given name from the server

Other Functions

The client also has several other functions:

Method Signature	Description
setAPIClientAuthenticationToken(authenticationToken: string)	Sets the API Client's authentication token
(static) getAuthenticationTokenPrivilegeLevel(authenticationToken: string) → {PrivilegeLevel}	Parses a given authentication token and returns its privilege level
(static) getCertificates(options?) → {Promise.<object>}	Retrieves the server and CA certificates from a remote server via HTTPS

Enumerations

PrivilegeLevel

Privilege Level Enumeration representing different privilege levels granted by an authentication token.

Enumerator	Description
PrivilegeLevel.NotAuthenticated	Not authenticated
PrivilegeLevel.Client	Authenticated with Client privileges
PrivilegeLevel.Administrator	Authenticated with Admin privileges
PrivilegeLevel.InitialAdmin	Authenticated as Initial Admin with privileges to claim the server
PrivilegeLevel.APIToken	Authenticated as Third Party Application

StatusCode

Status Code Enumeration representing different HTTP response codes.

Enumerator	Description
StatusCode.OK	Status Code for Ok 200
StatusCode.CREATED	Status Code for Created 201
StatusCode.ACCEPTED	Status Code for Accepted 202
StatusCode.NO_CONTENT	Status Code for No Content 204
StatusCode.BAD_REQUEST	Status Code for Bad Request 400
StatusCode.DENIED	Status Code for Denied 401
StatusCode.FORBIDDEN	Status Code for Forbidden 403
StatusCode.NOT_FOUND	Status Code for Not Found 404
StatusCode.UNSUPPORTED_MEDIA	Status Code for Unsupported Media 415
StatusCode.SERVER_ERROR	Status Code for Server Error 500

Basic Examples

Health Check

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5
6const main = async () => {
7  const apiClient = new APIClient({
8    address,
9    port,
10    https: {
11      request: {
12        rejectUnauthorized: false, // accepts any CA, not secure
13      },
14    },
15  });
16
17  console.log(await apiClient.healthCheck());
18};
19
20main();

Back to API Functions

Query Server State

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.queryServerState());
20};
21
22main();

Back to API Functions

Verify Authentication Token

1const { APIClient, StatusCode } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  const { status } = await apiClient.verifyAuthenticationToken();
20
21  if (status === StatusCode.NO_CONTENT) {
22    console.log('The authentication token is valid.');
23  } else {
24    console.error('The authentication token is invalid.');
25  }
26};
27
28main();

Back to API Functions

Passwordless Login

1const { APIClient, StatusCode } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5
6const main = async () => {
7  const apiClient = new APIClient({
8    address,
9    port,
10    https: {
11      request: {
12        rejectUnauthorized: false, // accepts any CA, not secure
13      },
14    },
15  });
16
17  // Client passwordless login (when Client password is not set)
18  const { status, data } = await apiClient.passwordlessLogin(PrivilegeLevel.Client);
19
20  if (status === StatusCode.OK && data?.authenticationToken) {
21    // update the API Client to use the authentication token
22    apiClient.setAPIClientAuthenticationToken(data.authenticationToken);
23
24    // check the authentication token is valid
25    if (apiClient.verifyAuthenticationToken(data.authenticationToken)) {
26      // perform operation permissable at Client privilege level
27      console.log(await apiClient.queryServerState());
28    }
29  }
30};
31
32main();

Back to API Functions

Password Login

1const { APIClient, StatusCode } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5
6const main = async () => {
7  const apiClient = new APIClient({
8    address,
9    port,
10    https: {
11      request: {
12        rejectUnauthorized: false, // accepts any CA, not secure
13      },
14    },
15  });
16
17  // Client password login (when Client password is set)
18  const { status, data } = await apiClient.passwordLogin(PrivilegeLevel.Client, 'My Client Password');
19
20  if (status === StatusCode.OK && data?.authenticationToken) {
21    // update the API Client to use the authentication token
22    apiClient.setAPIClientAuthenticationToken(data.authenticationToken);
23
24    // check the authentication token is valid
25    if (apiClient.verifyAuthenticationToken(data.authenticationToken)) {
26      // perform operation permissable at Client privilege level
27      console.log(await apiClient.queryServerState());
28    }
29  }
30};
31
32main();

Back to API Functions

Get Server Options

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.getServerOptions());
20};
21
22main();

Back to API Functions

Get Advanced Game Settings

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.getAdvancedGameSettings());
20};
21
22main();

Back to API Functions

Apply Advanced Game Settings

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.applyAdvancedGameSettings({
20    'FG.PlayerRules.GodMode': true,
21    'FG.PlayerRules.FlightMode': true,
22  }));
23};
24
25main();

Back to API Functions

Rename Server

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.renameServer('My Server'));
20};
21
22main();

Back to API Functions

Set Client Password

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.setClientPassword('My Client Password'));
20};
21
22main();

Back to API Functions

Set Admin Password

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.setAdminPassword('My Admin Password'));
20};
21
22main();

Back to API Functions

Set Auto Load Session Name

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.setAutoLoadSessionName('My Session'));
20
21  console.log((await apiClient.queryServerState()).data.serverGameState.autoLoadSessionName);
22};
23
24main();

Back to API Functions

Run Command

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.runCommand('FG.NetworkQuality'));
20};
21
22main();

Back to API Functions

Shutdown

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.shutdown());
20};
21
22main();

Back to API Functions

Apply Server Options

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.applyServerOptions({ 'FG.AutosaveInterval': '600' }));
20};
21
22main();

Back to API Functions

Create New Game

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.createNewGame({
20    SessionName: 'My Session',
21  }));
22};
23
24main();

Back to API Functions

Save Game

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.saveGame('My Save'));
20};
21
22main();

Back to API Functions

Delete Save File

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.deleteSaveFile('My Save'));
20};
21
22main();

Back to API Functions

Delete Save Session

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.deleteSaveSession('My Session'));
20};
21
22main();

Back to API Functions

Enumerate Sessions

Here is an example of how you can iterate all save names against all sessions:

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  const { data } = await apiClient.enumerateSessions();
20  const { currentSessionIndex } = data;
21  data.sessions.forEach((session, index) => {
22    console.log(`Session: ${session.sessionName}${(index === currentSessionIndex ? ' (Current)' : '')}`);
23    session.saveHeaders.forEach(({ saveName }) => {
24      console.log(`  Save Name: ${saveName}`);
25    });
26  });
27};
28
29main();

Example output:

Session: My Session (Current)
  Save Name: My Save

Back to API Functions

Load Game

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  console.log(await apiClient.loadGame('My Save'));
20};
21
22main();

Back to API Functions

Upload Save Game

1const fs = require('fs');
2const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
3
4const address = '127.0.0.1';
5const port = 7777;
6const authenticationToken = 'some API token';
7
8const main = async () => {
9  const apiClient = new APIClient({
10    address,
11    port,
12    authenticationToken,
13    https: {
14      request: {
15        rejectUnauthorized: false, // accepts any CA, not secure
16      },
17    },
18  });
19
20  try {
21    const buffer = fs.readFileSync('My Save 1.sav');
22    console.log(await apiClient.uploadSaveGame(buffer, 'My Save 1', true));
23  } catch (error) {
24    console.error('Error reading the file:', error);
25  }
26};
27
28main();

Back to API Functions

Download Save Game

1const fs = require('fs');
2const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
3
4const address = '127.0.0.1';
5const port = 7777;
6const authenticationToken = 'some API token';
7
8const main = async () => {
9  const apiClient = new APIClient({
10    address,
11    port,
12    authenticationToken,
13    https: {
14      request: {
15        rejectUnauthorized: false, // accepts any CA, not secure
16      },
17    },
18  });
19
20  try {
21    const buffer = await apiClient.downloadSaveGame('My Save 2');
22    fs.writeFileSync('My Save 2.sav', buffer);
23    console.log('Buffer written to file successfully!');
24  } catch (error) {
25    console.error('Error writing to file', error);
26  }
27};
28
29main();

Back to API Functions

Set API Client Authentication Token

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const authenticationToken = 'some API token';
6
7const main = async () => {
8  const apiClient = new APIClient({
9    address,
10    port,
11    authenticationToken,
12    https: {
13      request: {
14        rejectUnauthorized: false, // accepts any CA, not secure
15      },
16    },
17  });
18
19  apiClient.setAPIClientAuthenticationToken('some other token');
20};
21
22main();

Back to Other Functions

Get Authentication Token Privilege Level

1const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3console.log(APIClient.getAuthenticationTokenPrivilegeLevel('some API token'));

Back to Other Functions

Advanced Examples

Claim Server

Here is an example of how to claim a new server (set server name and admin password), set the client password and generate an API Token:

1const { APIClient, StatusCode, PrivilegeLevel } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
2
3const address = '127.0.0.1';
4const port = 7777;
5const serverName = 'My Server';
6const adminPassword = 'My Admin Password';
7const clientPassword = 'My Client Password';
8
9const main = async () => {
10  const apiClient = new APIClient({
11    address,
12    port,
13    https: {
14      request: {
15        rejectUnauthorized: false, // accepts any CA, not secure
16      },
17    },
18  });
19
20  try {
21    // passwordless login
22    {
23      const {
24        status,
25        data,
26      } = await apiClient.passwordlessLogin(PrivilegeLevel.InitialAdmin);
27
28      // check passwordlessLogin returned the 'Ok' status code
29      if (status === StatusCode.OK) {
30        // get the initial authentication token
31        const authenticationToken = data?.authenticationToken;
32        if (authenticationToken) {
33          // check the token is an InitialAdmin token
34          const privilegeLevel = APIClient.getAuthenticationTokenPrivilegeLevel(authenticationToken);
35          if (privilegeLevel === PrivilegeLevel.InitialAdmin) {
36            console.log(`${PrivilegeLevel.InitialAdmin} token obtained.`);
37
38            // update the API Client to use the InitialAdmin authentication token
39            apiClient.setAPIClientAuthenticationToken(authenticationToken);
40          } else {
41            throw new Error(`authentication token was not ${PrivilegeLevel.InitialAdmin}: ${privilegeLevel}.`);
42          }
43        } else {
44          throw new Error('passwordlessLogin did not return an authentication token.');
45        }
46      } else {
47        throw new Error(`passwordlessLogin status code was: ${status?.code}.`);
48      }
49    }
50
51    // claim the server
52    {
53      const {
54        status,
55        data,
56      } = await apiClient.claimServer(serverName, adminPassword);
57
58      // check claimServer returned the 'Ok' status code
59      if (status === StatusCode.OK) {
60        // get the authentication token
61        const authenticationToken = data?.authenticationToken;
62
63        if (authenticationToken) {
64          // check the token is an Administrator token
65          const privilegeLevel = APIClient.getAuthenticationTokenPrivilegeLevel(authenticationToken);
66          if (privilegeLevel === PrivilegeLevel.Administrator) {
67            console.log(`Server claimed (named and admin password set). ${PrivilegeLevel.Administrator} token obtained.`);
68
69            // update the API Client to use the Administrator authentication token
70            apiClient.setAPIClientAuthenticationToken(authenticationToken);
71          } else {
72            throw new Error(`authentication token was not ${PrivilegeLevel.Administrator}: ${privilegeLevel}.`);
73          }
74        } else {
75          throw new Error('claimServer did not return an authentication token.');
76        }
77      } else {
78        throw new Error(`claimServer status code was: ${status?.code}.`);
79      }
80    }
81
82    // set the client password
83    {
84      const {
85        status,
86      } = await apiClient.setClientPassword(clientPassword);
87
88      // check setClientPassword returned the 'No Content' status code
89      if (status === StatusCode.NO_CONTENT) {
90        console.log('Client password set.');
91      } else {
92        throw new Error('Client password was not set.');
93      }
94    }
95
96    // generate API token
97    {
98      const {
99        status,
100        data,
101      } = await apiClient.runCommand('server.GenerateAPIToken');
102
103      // check runCommand returned the 'Ok' status code and had a result
104      if (status === StatusCode.OK && data?.commandResult) {
105        console.log(`server.GenerateAPIToken command result: ${data?.commandResult}`);
106      } else {
107        throw new Error('server.GenerateAPIToken command failed');
108      }
109    }
110  } catch (error) {
111    console.error(`An error occurred: ${error.message}`);
112  }
113};
114
115main();

Back to API Functions

Get Certificates

APIClient.getCertificates() is a static utility function that can obtain the certificate(s) from the server.

Here is an example of how you might use it:

1const fs = require('fs');
2const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
3
4const address = '127.0.0.1';
5const port = 7777;
6
7const main = async () => {
8  const { server, ca } = await APIClient.getCertificates({
9    address,
10    port,
11    https: {
12      request: {
13        rejectUnauthorized: false, // accepts any CA, not secure
14      },
15    },
16  });
17  if (server?.pem) {
18    try {
19      console.log(`Server cert fingerprint512: ${server.cert?.fingerprint512}`);
20      fs.writeFileSync('serverCert.pem', server.pem);
21      console.log('Written server certificate to file successfully!');
22    } catch (error) {
23      console.error('Error writing to file', error);
24    }
25  }
26  if (ca?.pem) {
27    try {
28      console.log(`CA cert fingerprint512: ${ca.cert?.fingerprint512}`);
29      fs.writeFileSync('caCert.pem', ca.pem);
30      console.log('Written CA certificate to file successfully!');
31    } catch (error) {
32      console.error('Error writing to file', error);
33    }
34  }
35};
36
37main();

Then, instead of setting rejectUnauthorized: false, you can use the results from getCertificates() with the ca and checkServerIdentity options when creating a new APIClient. The latter is handy for Dedicated Servers that use self-signed certificates.

For example, you can check the host and certificate fingerprint like this:

1const fs = require('fs');
2const { APIClient } = require('@djwoodz/satisfactory-dedicated-server-https-api-client');
3
4const address = '127.0.0.1';
5const port = 7777;
6const fingerprint512 = 'some fingerprint';
7const ca = fs.readFileSync('serverCert.pem');
8
9const checkServerIdentity = (host, cert) => {
10  if (host !== address || cert?.fingerprint512 !== fingerprint512) {
11    throw new Error('Server identity check failed');
12  }
13};
14
15const main = async () => {
16  const apiClient = new APIClient({
17    address,
18    port,
19    https: {
20      request: {
21        ca,
22        checkServerIdentity,
23      },
24    },
25  });
26
27  console.log(await apiClient.healthCheck());
28};
29
30main();

Back to Other Functions