gologin 2.1.18 → 2.1.20

package/.eslintrc.json

@@ -102,7 +102,7 @@
     ],
     "max-lines": [
       "warn",
-      1500
+      2000
     ],
     "no-else-return": [
       "warn",

package/README.md

@@ -1,103 +1,179 @@
-# class GoLogin - class for working with <a href="https://gologin.com" target="_blank">gologin.com</a> API
-# Official Package
+# GoLogin Node.js SDK
+ This package provides functionality to run and stop GoLogin profiles with node.js and then connect the profiles to automation tools like Selenium, Puppetteer, Playwright etc.
 
-## Getting Started
-
-GoLogin supports Linux, MacOS and Windows platforms.
+# How does it work?
+ 1. You give SDK your dev token and profile id that you want to run
+ 2. SDK takes care of downloading, preparing your profile and starts the browser
+ 3. SDK gives you websocket url for automation tools
+ 4. You take this websocker url and connect it to the automation tool on your choice: Puppetteer, Selenium, Playwright etc
+ 5. Automation tool connects to browser and you can manage it through code
 
-### Installation
-
-`npm i gologin`
+## Getting Started
 
-for running example.js install puppeteer-core
+Where is token? API token is <a href="https://app.gologin.com/#/personalArea/TokenApi" target="_blank">here</a>.
 
-`npm i puppeteer-core`
+![Token API in Settings](https://user-images.githubusercontent.com/12957968/146891933-c3b60b4d-c850-47a5-8adf-bc8c37372664.gif)
 
-### Usage
 
-Where is token? API token is <a href="https://app.gologin.com/#/personalArea/TokenApi" target="_blank">here</a>.
-To have an access to the page below you need <a href="https://app.gologin.com/#/createUser" target="_blank">register</a> GoLogin account.
+### Installation
 
-![Token API in Settings](https://user-images.githubusercontent.com/12957968/146891933-c3b60b4d-c850-47a5-8adf-bc8c37372664.gif)
+`npm i gologin`
 
 ### Example
 
 ```js
-import puppeteer from 'puppeteer-core';
+import { GologinApi } from './src/gologin-api.js';
 
-import GoLogin from '../src/gologin.js';
+const GL = GologinApi({
+  token: 'your token',
+});
 
-const { connect } = puppeteer;
+const profile = await GL.createProfileRandomFingerprint('some name');
+const profileId = profile.id;
 
-(async () => {
-  const GL = new GoLogin({
-    token: 'yU0token',
-    profile_id: 'yU0Pr0f1leiD',
-  });
-
-  const { status, wsUrl } = await GL.start().catch((e) => {
-    console.trace(e);
+await GL.addGologinProxyToProfile(profileId, 'us');
+const browser = await GL.launch({ profileId });
+const page = await browser.newPage();
+await page.goto('https://linkedin.com');
+await new Promise((resolve) => setTimeout(resolve, 5000));
+await browser.close();
+await GL.stop();
+```
 
-    return { status: 'failure' };
-  });
+###
+### Methods
+#### constructor
 
-  if (status !== 'success') {
-    console.log('Invalid status');
+Required options:
+- `token` <[string]> **Required** - your API <a href="https://gologin.com/#/personalArea/TokenApi" target="_blank">token</a>
 
-    return;
-  }
+Optional options:
+- `profile_id` <[string]> - profile ID (NOT PROFILE NAME) will be generated if not specified
+- `executablePath` <[string]> path to executable Orbita file. Orbita will be downloaded automatically if not specified
+- `extra_params` arrayof <[string]> additional flags for browser start. For example: '--headles', '--load-extentions=path/to/extension'
+- `uploadCookiesToServer` <[boolean]> upload cookies to server after profile stopping (default false). It allows you to export cookies from api later.
+- `writeCookesFromServer` <[boolean]> if you have predefined cookies and you want browser to import it (default true).
+- `tmpdir` <[string]> absolute path to the directtory where you want to store user-data-dir. Default path in tmp folder will be picked if no specified
+- `vncPort` <[integer]> port of VNC server if you using it
 
-  const browser = await connect({
-    browserWSEndpoint: wsUrl.toString(),
-    ignoreHTTPSErrors: true,
-  });
+```js
+const GL = new GoLogin({
+    token: 'your token',
+    profile_id: 'profile id',
+    extra_params: ["--headless", "--load-extentions=path/to/extension"]
+});
+```
 
-  const page = await browser.newPage();
-  await page.goto('https://myip.link/mini');
-  console.log(await page.content());
-  await browser.close();
-  await GL.stop();
-})();
+#### createProfileRandomFingerprint - you pass os ('lin', 'win', 'mac') and profile name and we give you brand new shiny profile
+```js
+const GL = new GoLogin({
+    token: 'your token',
+    profile_id: 'profile id',
+    extra_params: ["--headless", "--load-extentions=path/to/extension"]
+});
+const profile = await gl.createProfileRandomFingerprint("some name")
+const profileId = profile.id
 ```
 
-### Running example:
 
-`DEBUG=gologin* node example.js`
+#### createProfileWithCustomParams - This method creates a profile and you can pass any particular params to it. Full list of params you can find here - https://api.gologin.com/docs
+```js
+const GL = GoLogin({
+	"token": "your token",
+	})
+const profile = await gl.createProfileWithCustomParams({
+    "os": "lin",
+    "name": "some name",
+    "navigator": {
+        "userAgent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
+        "resolution": "1920x1080",
+        "language": "en-US",
+        "platform": "Linux x86_64",
+        "hardwareConcurrency": 8,
+        "deviceMemory": 8,
+        "maxTouchPoints": 0
+    }
+})
+const profileId = profile.id
+```
 
-###
-### Methods
-#### constructor
+#### updateUserAgentToLatestBrowser - user agent is one of the most important thing in your fingerprint. It decides which browser version to run. This method help you to keep useragent up to date.
+```js
+const GL = GoLogin({
+	"token": "your token",
+	})
+await GL.updateUserAgentToLatestBrowser(["profineId1", "profileId2"], "workspceId(optional)")
+```
 
-- `options` <[Object]> Options for profile
-    - `autoUpdateBrowser` <[boolean]> do not ask whether download new browser version (default false)
-    - `token` <[string]> your API <a href="https://gologin.com/#/personalArea/TokenApi" target="_blank">token</a>
-    - `profile_id` <[string]> profile ID
-    - `executablePath` <[string]> path to executable Orbita file. Orbita will be downloaded automatically if not specified.
-    - `remote_debugging_port` <[int]> port for remote debugging
-    - `vncPort` <[integer]> port of VNC server if you using it
-    - `tmpdir` <[string]> path to temporary directore for saving profiles
-    - `extra_params` arrayof <[string]> extra params for browser orbita (ex. extentions etc.)
-    - `uploadCookiesToServer` <[boolean]> upload cookies to server after profile stopping (default false)
-    - `writeCookesFromServer` <[boolean]> download cookies from server and write to profile cookies file (default true)
-    - `skipOrbitaHashChecking` <[boolean]> skip hash checking for Orbita after downloading process (default false)
+#### addGologinProxyToProfile - Gologin provides high quality proxies with free traffic for paid users. Here you can add gologin proxy to profile, just pass country code
+```js
+const GL = GoLogin({
+	"token": "your token",
+	})
+await GL.addGologinProxyToProfile("profileId", "us")
+```
 
+#### addCookiesToProfile - You can pass cookies to the profile and browser will import it before starting
 ```js
-import GoLogin from '../src/gologin.js';
-const GL = new GoLogin({
-    token: 'yU0token',
-    profile_id: 'yU0Pr0f1leiD',
-});
+const GL = GoLogin({
+	"token": "your token",
+	})
+
+await GL.addCookiesToProfile("profileId", [
+    {
+        "name": "session_id",
+        "value": "abc123",
+        "domain": "example.com",
+        "path": "/",
+        "expirationDate": 1719161018.307793,
+        "httpOnly": True,
+        "secure": True
+    },
+    {
+        "name": "user_preferences",
+        "value": "dark_mode",
+        "domain": "example.com",
+        "path": "/settings",
+        "sameSite": "lax"
+    }
+])
+```
+
+#### refreshProfilesFingerprint - Replaces your profile fingerprint with a new one
+```js
+const GL = GoLogin({
+	"token": "your token",
+	})
+
+await GL.refreshProfilesFingerprint(["profileId1", "profileId2"])
 ```
 
-#### start()  
+#### changeProfileProxy - allows you to set a proxy to a profile
+```js
+const GL = GoLogin({
+	"token": "your token",
+	})
+await GL.changeProfileProxy("profileId", { "mode": "http", "host": "somehost.com", "port": 109, "username": "someusername", "password": "somepassword"})
+```
 
-- returns: <[object]> { status, wsUrl } 
+#### launch() - starts browser with profile id, returning WebSocket url for puppeteer
+```js
+const GL = GoLogin({
+	"token": "your token",
+	})
+await GL.launch({ profileId: 'some profileId' })
+```
 
-start browser with profile id, returning WebSocket url for puppeteer
 
-#### stop()  
+#### exit() stops browser and uploads it to the storage
+```js
+const GL = GoLogin({
+	"token": "your token",
+	})
+await GL.launch({ profileId: 'some profileId' })
+await GL.exit()
+```
 
-stop browser with profile id
 
 ### DEBUG
 

package/index.d.ts

@@ -1,5 +1,7 @@
 import { type Browser } from 'puppeteer-core/lib/Browser';
 
+import { CreateCustomBrowserValidation, BrowserProxyCreateValidation } from './types/profile-params';
+
 export const OPERATING_SYSTEMS = {
   win: 'win',
   lin: 'lin',
@@ -45,12 +47,29 @@ type LaunchParams =
     os: OsType;
   };
 
-type LaunchFn = (params?: LaunchParams) => Promise<{ browser: Browser }>;
+type Cookie = {
+  name: string;
+  value: string;
+  domain: string;
+  path: string;
+  expirationDate?: number;
+  creationDate?: number;
+  hostOnly?: boolean;
+  httpOnly?: boolean;
+  sameSite?: 'no_restriction' | 'lax' | 'strict';
+  secure?: boolean;
+  session?: boolean;
+  url?: string;
+};
 
 type GologinApiType = {
-  launch: LaunchFn;
+  launch: (params?: LaunchParams) => Promise<{ browser: Browser }>;
   exit: (status = 0) => Promise<void>;
-  delay: (ms: number) => Promise<void>;
+  createCustom: (params: CreateCustomBrowserValidation) => Promise<string>;
+  updateProfileFingerprint: (profileId: string[]) => Promise<void>;
+  updateUserAgentToLatestBrowser: (profileIds: string[], workspaceId?: string) => Promise<void>;
+  updateProfileProxy: (profileId: string, proxyData: BrowserProxyCreateValidation) => Promise<void>;
+  addCookiesToProfile: (profileId: string, cookies: Cookie[]) => Promise<void>;
 };
 
 type GologinApiParams = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gologin",
-  "version": "2.1.18",
+  "version": "2.1.20",
   "description": "A high-level API to control Orbita browser over GoLogin API",
   "types": "./index.d.ts",
   "main": "./src/gologin.js",

package/src/gologin-api.js

@@ -1,17 +1,19 @@
 import puppeteer from 'puppeteer-core';
 
 import GoLogin from './gologin.js';
+import { API_URL, getOsAdvanced } from './utils/common.js';
 
-export function getDefaultParams() {
-  return {
-    token: process.env.GOLOGIN_API_TOKEN,
-    profile_id: process.env.GOLOGIN_PROFILE_ID,
-    executablePath: process.env.GOLOGIN_EXECUTABLE_PATH,
-    autoUpdateBrowser: true,
-  };
-}
+const trafficLimitMessage =
+  'You dont have free traffic to use the proxy. Please go to app https://app.gologin.com/ and buy some traffic if you want to use the proxy';
 
-const createLegacyGologin = ({ profileId, ...params }) => {
+export const getDefaultParams = () => ({
+  token: process.env.GOLOGIN_API_TOKEN,
+  profile_id: process.env.GOLOGIN_PROFILE_ID,
+  executablePath: process.env.GOLOGIN_EXECUTABLE_PATH,
+  autoUpdateBrowser: true,
+});
+
+const createGologinProfileManager = ({ profileId, ...params }) => {
   const defaults = getDefaultParams();
   const mergedParams = {
     ...defaults,
@@ -27,9 +29,7 @@ const createLegacyGologin = ({ profileId, ...params }) => {
 
 const createdApis = [];
 
-export const delay = (ms = 250) => new Promise((res) => setTimeout(res, ms));
-
-export function GologinApi({ token }) {
+export const GologinApi = ({ token }) => {
   if (!token) {
     throw new Error('GoLogin API token is missing');
   }
@@ -38,7 +38,7 @@ export function GologinApi({ token }) {
   const legacyGls = [];
 
   const launchLocal = async (params) => {
-    const legacyGologin = createLegacyGologin({
+    const legacyGologin = createGologinProfileManager({
       ...params,
       token,
     });
@@ -48,9 +48,9 @@ export function GologinApi({ token }) {
       await legacyGologin.setProfileId(id);
     }
 
-    const started = await legacyGologin.start();
+    const startedProfile = await legacyGologin.start();
     const browser = await puppeteer.connect({
-      browserWSEndpoint: started.wsUrl,
+      browserWSEndpoint: startedProfile.wsUrl,
       ignoreHTTPSErrors: true,
     });
 
@@ -61,7 +61,7 @@ export function GologinApi({ token }) {
   };
 
   const launchCloudProfile = async (params) => {
-    const legacyGologin = createLegacyGologin({
+    const legacyGologin = createGologinProfileManager({
       ...params,
       token,
     });
@@ -94,7 +94,195 @@ export function GologinApi({ token }) {
       return launchLocal(params);
     },
 
-    async exit(status = 0) {
+    async createProfileWithCustomParams(options) {
+      const response = await fetch(`${API_URL}/browser/custom`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'User-Agent': 'gologin-api',
+        },
+        body: JSON.stringify(options),
+      });
+
+      if (response.status === 400) {
+        throw new Error(`gologin failed account creation with status code, ${response.status} DATA  ${JSON.stringify(await response.json())}`);
+      }
+
+      if (response.status === 500) {
+        throw new Error(`gologin failed account creation with status code, ${response.status}`);
+      }
+
+      const profile = await response.json();
+
+      return profile.id;
+    },
+
+    async refreshProfilesFingerprint(profileIds) {
+      if (!profileIds) {
+        throw new Error('Profile ID is required');
+      }
+
+      const response = await fetch(`${API_URL}/browser/fingerprints`, {
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'User-Agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+        body: JSON.stringify({ browsersIds: profileIds }),
+      });
+
+      return response.json();
+    },
+
+    async createProfileRandomFingerprint(name = '') {
+      const osInfo = await getOsAdvanced();
+      const { os, osSpec } = osInfo;
+      const resultName = name || 'api-generated';
+
+      const response = await fetch(`${API_URL}/browser/quick`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'User-Agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          os,
+          osSpec,
+          name: resultName,
+        }),
+      });
+
+      return response.json();
+    },
+
+    async updateUserAgentToLatestBrowser(profileIds, workspaceId = '') {
+      let url = `${API_URL}/browser/update_ua_to_new_browser_v`;
+      if (workspaceId) {
+        url += `?currentWorkspace=${workspaceId}`;
+      }
+
+      const response = await fetch(url, {
+        method: 'PATCH',
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'User-Agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ browserIds: profileIds, updateUaToNewBrowserV: true, updateAllProfiles: false, testOrbita: false }),
+      });
+
+      return response.json();
+    },
+
+    async changeProfileProxy(profileId, proxyData) {
+      console.log(proxyData);
+      const response = await fetch(`${API_URL}/browser/${profileId}/proxy`, {
+        method: 'PATCH',
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'user-agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(proxyData),
+      });
+
+      return response.status;
+    },
+
+    getAvailableType(availableTrafficData) {
+      switch (true) {
+        case availableTrafficData.mobileTrafficData.trafficUsedBytes > availableTrafficData.mobileTrafficData.trafficLimitBytes:
+          return 'mobile';
+        case availableTrafficData.residentialTrafficData.trafficUsedBytes < availableTrafficData.residentialTrafficData.trafficLimitBytes:
+          return 'resident';
+        case availableTrafficData.dataCenterTrafficData.trafficUsedBytes < availableTrafficData.dataCenterTrafficData.trafficLimitBytes:
+          return 'dataCenter';
+        default:
+          return 'none';
+      }
+    },
+
+    async addGologinProxyToProfile(profileId, countryCode, proxyType = '') {
+      if (!proxyType) {
+        const availableTraffic = await fetch(`${API_URL}/users-proxies/geolocation/traffic`, {
+          headers: {
+            Authorization: `Bearer ${token}`,
+            'user-agent': 'gologin-api',
+            'Content-Type': 'application/json',
+          },
+        });
+
+        const availableTrafficData = await availableTraffic.json();
+        console.log(availableTrafficData);
+        const availableType = this.getAvailableType(availableTrafficData);
+        if (availableType === 'none') {
+          throw new Error(trafficLimitMessage);
+        }
+
+        console.log(availableType);
+        proxyType = availableType;
+      }
+
+      let isDc = false;
+      let isMobile = false;
+
+      switch (proxyType) {
+        case 'mobile':
+          isMobile = true;
+          isDc = false;
+          break;
+        case 'resident':
+          isMobile = false;
+          isDc = false;
+          break;
+        case 'dataCenter':
+          isMobile = false;
+          isDc = true;
+          break;
+        default:
+          throw new Error('Invalid proxy type');
+      }
+
+      const proxyResponse = await fetch(`${API_URL}/users-proxies/mobile-proxy`, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'user-agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        method: 'POST',
+        body: JSON.stringify({
+          countryCode,
+          isDc,
+          isMobile,
+          profileIdToLink: profileId,
+        }),
+      });
+
+      const proxy = await proxyResponse.json();
+      if (proxy.trafficLimitBytes < proxy.trafficUsedBytes) {
+        throw new Error(trafficLimitMessage);
+      }
+
+      return proxy;
+    },
+
+    async addCookiesToProfile(profileId, cookies) {
+      const response = await fetch(`${API_URL}/browser/${profileId}/cookies?fromUser=true`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'user-agent': 'gologin-api',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(cookies),
+      });
+
+      return response.status;
+    },
+
+    async exit() {
       Promise.allSettled(browsers.map((browser) => browser.close()));
       Promise.allSettled(
         legacyGls.map((gl) => gl.stopLocal({ posting: false })),
@@ -103,14 +291,12 @@ export function GologinApi({ token }) {
         legacyGls.map((gl) => gl.stopRemote({ posting: true })),
       );
     },
-
-    delay,
   };
 
   createdApis.push(api);
 
   return api;
-}
+};
 
 export function exitAll() {
   Promise.allSettled(createdApis.map((api) => api.exit()));

package/src/gologin.js

@@ -116,36 +116,6 @@ export class GoLogin {
     }
   }
 
-  async getNewFingerPrint(os) {
-    debug('GETTING FINGERPRINT');
-
-    const fpResponse = await requests.get(`${API_URL}/browser/fingerprint?os=${os}`, {
-      json: true,
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-    });
-
-    return fpResponse?.body || {};
-  }
-
-  async profiles() {
-    const profilesResponse = await requests.get(`${API_URL}/browser/v2`, {
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-
-      },
-    });
-
-    if (profilesResponse.statusCode !== 200) {
-      throw new Error('Gologin /browser response error');
-    }
-
-    return JSON.parse(profilesResponse.body);
-  }
-
   async getProfile(profile_id) {
     const id = profile_id || this.profile_id;
     debug('getProfile', this.access_token, id);
@@ -509,6 +479,7 @@ export class GoLogin {
     const prefFileExists = await access(pref_file_name).then(() => true).catch(() => false);
     if (!prefFileExists) {
       debug('Preferences file not exists waiting', pref_file_name, '. Using empty profile');
+      await mkdir(join(profilePath, 'Default'), { recursive: true });
       await writeFile(pref_file_name, '{}');
     }
 
@@ -1234,48 +1205,6 @@ export class GoLogin {
     return response.body.id;
   }
 
-  async createCustom(options) {
-    debug('createCustomProfile', options);
-    const response = await requests.post(`${API_URL}/browser/custom`, {
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-      json: options,
-    });
-
-    if (response.statusCode === 400) {
-      throw new Error(`gologin failed account creation with status code, ${response.statusCode} DATA  ${JSON.stringify(response.body.message)}`);
-    }
-
-    if (response.statusCode === 500) {
-      throw new Error(`gologin failed account creation with status code, ${response.statusCode}`);
-    }
-
-    debug(JSON.stringify(response));
-
-    return response.body.id;
-  }
-
-  async quickCreateProfile(name = '') {
-    const osInfo = await getOsAdvanced();
-    const { os, osSpec } = osInfo;
-    const resultName = name || 'api-generated';
-
-    return requests.post(`${API_URL}/browser/quick`, {
-      headers: {
-        'Authorization': `Bearer ${this.access_token}`,
-        'User-Agent': 'gologin-api',
-      },
-      json: {
-        os,
-        osSpec,
-        name: resultName,
-      },
-    })
-      .then(res => res.body);
-  }
-
   async delete(pid) {
     const profile_id = pid || this.profile_id;
     await requests.delete(`${API_URL}/browser/${profile_id}`, {
@@ -1451,7 +1380,6 @@ export class GoLogin {
   }
 
   async start() {
-
     await this.createStartup();
     // await this.createBrowserExtension();
     const wsUrl = await this.spawnBrowser();
@@ -1524,22 +1452,72 @@ export class GoLogin {
     }
   }
 
+  // api for users to manage their profiles
+  async changeProfileProxy(proxyData) {
+    return updateProfileProxy(this.profile_id, this.access_token, proxyData);
+  }
+
+  async changeProfileUserAgent(userAgent) {
+    return updateProfileUserAgent(this.profile_id, this.access_token, userAgent);
+  }
+
+  async changeProfileResolution(resolution) {
+    return updateProfileResolution(this.profile_id, this.access_token, resolution);
+  }
+
   getAvailableFonts() {
     return fontsCollection
       .filter(elem => elem.fileNames)
       .map(elem => elem.name);
   }
 
-  async changeProfileResolution(resolution) {
-    return updateProfileResolution(this.profile_id, this.access_token, resolution);
+  async quickCreateProfile(name = '') {
+    const osInfo = await getOsAdvanced();
+    const { os, osSpec } = osInfo;
+    const resultName = name || 'api-generated';
+
+    return requests.post(`${API_URL}/browser/quick`, {
+      headers: {
+        'Authorization': `Bearer ${this.access_token}`,
+        'User-Agent': 'gologin-api',
+      },
+      json: {
+        os,
+        osSpec,
+        name: resultName,
+      },
+    })
+      .then(res => res.body);
   }
 
-  async changeProfileUserAgent(userAgent) {
-    return updateProfileUserAgent(this.profile_id, this.access_token, userAgent);
+  async profiles() {
+    const profilesResponse = await requests.get(`${API_URL}/browser/v2`, {
+      headers: {
+        'Authorization': `Bearer ${this.access_token}`,
+        'User-Agent': 'gologin-api',
+
+      },
+    });
+
+    if (profilesResponse.statusCode !== 200) {
+      throw new Error('Gologin /browser response error');
+    }
+
+    return JSON.parse(profilesResponse.body);
   }
 
-  async changeProfileProxy(proxyData) {
-    return updateProfileProxy(this.profile_id, this.access_token, proxyData);
+  async getNewFingerPrint(os) {
+    debug('GETTING FINGERPRINT');
+
+    const fpResponse = await requests.get(`${API_URL}/browser/fingerprint?os=${os}`, {
+      json: true,
+      headers: {
+        'Authorization': `Bearer ${this.access_token}`,
+        'User-Agent': 'gologin-api',
+      },
+    });
+
+    return fpResponse?.body || {};
   }
 }
 

package/src/utils/utils.js

@@ -47,3 +47,4 @@ export const findLatestBrowserVersionDirectory = (browserPath) => {
   return folderName;
 };
 
+export const delay = (ms = 250) => new Promise((res) => setTimeout(res, ms));

package/types/profile-params.d.ts

@@ -0,0 +1,127 @@
+export type OS = 'lin' | 'mac' | 'win' | 'android';
+export type T_OS_SPEC = 'M1' | 'M2' | 'M3' | 'M3' | 'win11' | '';
+
+export type IBookmarkFoldersObj = {
+  [key: string]: {
+    name: string;
+    children: Array<{
+      name: string;
+      url: string;
+    }>;
+  };
+}
+
+export type NavigatorModel = {
+  userAgent: string;
+  resolution: string;
+  language: string;
+  platform: string;
+  hardwareConcurrency: number;
+  deviceMemory: number;
+  maxTouchPoints?: number;
+}
+
+export type TimezoneModel = {
+  enabled: boolean;
+  fillBasedOnIp: boolean;
+  timezone: string;
+}
+
+export type GeolocationModel = {
+  mode: 'prompt' | 'block' | 'allow';
+  enabled: boolean;
+  customize: boolean;
+  fillBasedOnIp: boolean;
+  latitude: number;
+  longitude: number;
+  accuracy: number;
+}
+
+export type AudioContextModel = {
+  enable: boolean;
+  noiseValue: number;
+}
+
+export type CanvasModel = {
+  mode: 'off' | 'noise';
+  noise?: number;
+}
+
+export type FontsModel = {
+  enableMasking: boolean;
+  enableDOMRect: boolean;
+  families: string[];
+}
+
+export type MediaDevicesModel = {
+  enableMasking: boolean;
+  videoInputs: number;
+  audioInputs: number;
+  audioOutputs: number;
+}
+
+export type WebRTCModel = {
+  mode: 'real' | 'public';
+  enabled: boolean;
+  customize: boolean;
+  localIpMasking: boolean;
+  fillBasedOnIp: boolean;
+  publicIp: string;
+  localIps: string[];
+}
+
+export type WebGlModel = {
+  mode: 'off' | 'noise';
+  getClientRectsNoise: number;
+  noise?: number;
+}
+
+export type ClientRectsModel = {
+  mode: 'off' | 'noise';
+  noise: number;
+}
+
+export type WebGlMetadataModel {
+  mode: 'off' | 'mask';
+  vendor: string;
+  renderer: string;
+}
+
+export type BrowserProxyCreateValidation {
+  mode: 'http' | 'https' | 'socks4' | 'socks5' | 'geolocation' | 'none' | 'tor' | 'gologin';
+  host: string;
+  port: number;
+  username?: string;
+  password?: string;
+  changeIpUrl?: string;
+  autoProxyRegion?: string;
+  torProxyRegion?: string;
+}
+
+export declare class CreateCustomBrowserValidation {
+  name?: string;
+  notes?: string;
+  autoLang?: boolean;
+  lockEnabled?: boolean;
+  folderName?: string;
+  bookmarks?: IBookmarkFoldersObj;
+  os: OS;
+  osSpec?: T_OS_SPEC;
+  devicePixelRatio?: number;
+  navigator?: NavigatorModel;
+  proxy?: BrowserProxyCreateValidation;
+  dns?: string;
+  timezone?: TimezoneModel;
+  geolocation?: GeolocationModel;
+  audioContext?: AudioContextModel;
+  canvas?: CanvasModel;
+  fonts?: FontsModel;
+  mediaDevices?: MediaDevicesModel;
+  webRTC?: WebRTCModel;
+  webGL?: WebGlModel;
+  clientRects?: ClientRectsModel;
+  webGLMetadata?: WebGlMetadataModel;
+  chromeExtensions?: string[];
+  userChromeExtensions?: string[];
+  folders?: string[];
+}