gologin 2.2.7 → 2.2.9

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 Combined changelog for GoLogin node.js SDK
 
+## [2.2.9] 2026-06-08
+
+### Fixes
+
+* Disabled fonts downloading which was throwing errors
+* Type fixes
+* Added Proxy Error message to socks5 proxies check fails
+* Added (Gologin) prefix where gologin proxies failed
+* Profile start timing optimization
+
 ## [2.2.7] 2026-02-06
 
 ### Fixes

package/examples/puppeter/cloud-browser.js

@@ -1,17 +1,31 @@
-// Gologin provides a cloud browser that can be used to run puppeteer aytomation.
-// It will handle the browser start and close management - you just need to control the browser with pupputter
-import { GologinApi } from 'gologin';
+// Gologin provides a cloud browser that can be used to run puppeteer automation.
+// It will handle the browser start and close management - you just need to control the browser with puppeteer
+import puppeteer from 'puppeteer-core';
 
 const token = process.env.GL_API_TOKEN || 'your dev token here';
-const gologin = GologinApi({
-  token,
-});
+const profileId = 'profile ID';
+
+const CLOUD_BROWSER_URL = `https://cloudbrowser.gologin.com/connect?token=${token}&profile=${profileId}`;
+const STOP_PROFILE_URL = `https://api.gologin.com/browser/${profileId}/web`;
+
+async function stopProfile() {
+  await fetch(STOP_PROFILE_URL, {
+    method: 'DELETE',
+    headers: { Authorization: `Bearer ${token}` },
+  });
+}
 
 async function main() {
-  const { browser } = await gologin.launch({
-    cloud: true,
-    // pass profileId parameter if you want to run particular profile
-    // profileId: 'your profileId here',
+  const response = await fetch(CLOUD_BROWSER_URL);
+
+  if (!response.ok) {
+    const errorReason = response.headers.get('X-Error-Reason');
+    throw new Error(`Failed to start cloud browser: ${errorReason ?? response.statusText}`);
+  }
+
+  const browser = await puppeteer.connect({
+    browserWSEndpoint: CLOUD_BROWSER_URL,
+    ignoreHTTPSErrors: true,
   });
 
   const page = await browser.newPage();
@@ -21,10 +35,7 @@ async function main() {
     (elt) => elt?.innerText?.trim(),
   );
 
-  console.log('status', status);
-
   return status;
 }
 
-main().catch(console.error)
-  .finally(gologin.exit);
+main().catch(console.error).finally(stopProfile);

package/index.d.ts

@@ -2,12 +2,12 @@ import { Browser } from 'puppeteer-core/lib/Browser';
 
 import { CreateCustomBrowserValidation, BrowserProxyCreateValidation } from './types/profile-params';
 
-export const OPERATING_SYSTEMS = {
-  win: 'win',
-  lin: 'lin',
-  mac: 'mac',
-  android: 'android',
-} as const;
+export declare const OPERATING_SYSTEMS: {
+  readonly win: 'win';
+  readonly lin: 'lin';
+  readonly mac: 'mac';
+  readonly android: 'android';
+};
 export type OsType = (typeof OPERATING_SYSTEMS)[keyof typeof OPERATING_SYSTEMS];
 
 type CloudLaunchParams = {
@@ -94,6 +94,63 @@ type GologinApiParams = {
   token: string;
 };
 
+/** Options for the GoLogin class constructor (advanced usage, custom wrappers). */
+export type GoLoginOptions = {
+  token?: string;
+  profile_id?: string;
+  password?: string;
+  extra_params?: string[];
+  executablePath?: string;
+  vncPort?: number;
+  tmpdir?: string;
+  waitWebsocket?: boolean;
+  isCloudHeadless?: boolean;
+  skipOrbitaHashChecking?: boolean;
+  uploadCookiesToServer?: boolean;
+  writeCookiesFromServer?: boolean;
+  remote_debugging_port?: number;
+  timezone?: { timezone: string; country?: string; city?: string; ip?: string; ll?: [number, number]; accuracy?: number, stateProv?: string, languages?: string }; 
+  args?: string[];
+  restoreLastSession?: boolean;
+  browserMajorVersion?: number;
+  proxyCheckTimeout?: number;
+  proxyCheckAttempts?: number;
+  autoUpdateBrowser?: boolean;
+  checkBrowserUpdate?: boolean;
+};
+
+/** Return type of GoLogin#start() — use wsUrl to connect with Puppeteer. */
+export type GoLoginStartResult = {
+  status: 'success';
+  wsUrl: string;
+  resolution?: { width: number; height: number };
+};
+
+/**
+ * GoLogin class for advanced usage and custom wrappers.
+ * Use when you need direct control over the browser lifecycle (e.g. custom launchLocal,
+ * multiple instances, or access to wsUrl from start() for Puppeteer).
+ *
+ * @example
+ * import { GoLogin } from 'gologin';
+ * const gologin = new GoLogin({ token: 'YOUR_TOKEN', profile_id: 'PROFILE_ID' });
+ * const { wsUrl } = await gologin.start();
+ * // connect with puppeteer.connect({ browserWSEndpoint: wsUrl })
+ * await gologin.stop();
+ */
+export declare class GoLogin {
+  constructor(options?: GoLoginOptions);
+  start(): Promise<GoLoginStartResult>;
+  stop(): Promise<void>;
+  startLocal(): Promise<{ status: string, wsUrl: string }>;
+  stopLocal(options?: { posting?: boolean }): Promise<void>;
+  setProfileId(profile_id: string): Promise<void>;
+  getProfile(profile_id?: string): Promise<Record<string, unknown>>;
+  quickCreateProfile(name?: string): Promise<{ id: string }>;
+  profilePath(): string;
+  commitProfile(): Promise<void>;
+}
+
 export declare function getDefaultParams(): {
   token: string | undefined;
   profile_id: string | undefined;

package/package.json

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

package/src/browser/browser-checker.js

@@ -361,8 +361,11 @@ export class BrowserChecker {
 
   getLatestBrowserVersion() {
     const userOs = getOS();
+    const options = {
+      json: true,
+    };
 
-    return makeRequest(`${API_URL}/gologin-global-settings/latest-browser-info?os=${userOs}`);
+    return makeRequest(`${API_URL}/gologin-global-settings/latest-browser-info?os=${userOs}`, options);
   }
 
   get getOrbitaPath() {

package/src/cookies/cookies-manager.js

@@ -128,8 +128,6 @@ export const loadCookiesFromFile = async (filePath, isSecondTry = false, profile
     console.log('error in loadCookiesFromFile', error.message);
   }
 
-  console.log(1);
-
   try {
     db = await getDB(filePath);
     const cookiesRows = await db.all('select * from cookies');

package/src/gologin.js

@@ -80,11 +80,10 @@ export class GoLogin {
     this.restoreLastSession = options.restoreLastSession || true;
     this.processSpawned = null;
     this.processKillTimeout = 1 * 1000;
-    this.browserMajorVersion = 0;
-    this.newProxyOrbbitaMajorVersion = 135;
+    this.browserMajorVersion = options.browserMajorVersion || 0;
+    this.newProxyOrbitaMajorVersion = 135;
     this.proxyCheckTimeout = options.proxyCheckTimeout || 13 * 1000;
     this.proxyCheckAttempts = options.proxyCheckAttempts || 3;
-    this.browserLatestMajorVersion = 137;
 
     if (process.env.DISABLE_TELEMETRY !== 'true') {
       Sentry.init({
@@ -329,7 +328,7 @@ export class GoLogin {
       },
     };
 
-    if (this.browserMajorVersion >= this.newProxyOrbbitaMajorVersion && profileData.proxy?.mode !== 'none') {
+    if (this.browserMajorVersion >= this.newProxyOrbitaMajorVersion && profileData.proxy?.mode !== 'none') {
       let proxyServer = `${profileData.proxy.mode}://`;
       if (profileData.proxy.username) {
         const encodedUsername = encodeURIComponent(profileData.proxy.username || '');
@@ -398,6 +397,7 @@ export class GoLogin {
   async downloadProfileAndExtract(profile, local) {
     let profile_folder;
     const profilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`);
+
     const profileZipExists = await access(this.profile_zip_path).then(() => true).catch(() => false);
 
     if (!(local && profileZipExists)) {
@@ -458,26 +458,16 @@ export class GoLogin {
 
   async createStartup(local = false) {
     const profilePath = join(this.tmpdir, `gologin_profile_${this.profile_id}`);
-    await rimraf(profilePath, () => null);
-    debug('-', profilePath, 'dropped');
-    const profile = await this.getProfile();
+
+    const [profile] = await Promise.all([
+      this.getProfile(),
+      new Promise((resolve) => rimraf(profilePath, resolve)).then(() => debug('-', profilePath, 'dropped')),
+    ]);
+
     if (!profile) {
       throw new Error('Error fetching profile data');
     }
 
-    if (!this.executablePath) {
-      const { userAgent } = profile.navigator;
-      try {
-        const [browserMajorVersion] = userAgent.split('Chrome/')[1].split('.');
-        this.browserMajorVersion = Number(browserMajorVersion);
-        await this.checkBrowser(browserMajorVersion);
-      } catch (e) {
-        const latestVersionNumber = await this.getLatestBrowserVersion();
-        this.browserMajorVersion = latestVersionNumber;
-        await this.checkBrowser(latestVersionNumber);
-      }
-    }
-
     const { navigator = {}, fonts, os: profileOs } = profile;
     this.fontsMasking = fonts?.enableMasking;
     this.profileOs = profileOs;
@@ -488,10 +478,7 @@ export class GoLogin {
         OS_PLATFORM === 'linux' && profileOs !== 'lin'
       );
 
-    const {
-      resolution = '1920x1080',
-    } = navigator;
-
+    const { resolution = '1920x1080' } = navigator;
     const [screenWidth, screenHeight] = resolution.split('x');
     this.resolution = {
       width: parseInt(screenWidth, 10),
@@ -499,87 +486,8 @@ export class GoLogin {
     };
 
     this.createCookiesTableQuery = profile.createCookiesTableQuery;
-    if (profile.storageInfo.isNewProfile) {
-      this.isFirstSession = true;
-      await this.createZeroProfile(profile.createCookiesTableQuery);
-    } else {
-      this.isFirstSession = false;
-      await this.downloadProfileAndExtract(profile, local);
-    }
-
-    await _promises.rm(join(profilePath, 'Default', 'Sync Data'), { recursive: true }).catch(() => null);
-    const pref_file_name = join(profilePath, 'Default', 'Preferences');
-    debug('reading', pref_file_name);
-
-    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, '{}');
-    }
 
-    const preferences_raw = await readFile(pref_file_name);
-    const preferences = JSON.parse(preferences_raw.toString());
     let proxy = get(profile, 'proxy');
-    const chromeExtensions = get(profile, 'chromeExtensions') || [];
-    const userChromeExtensions = get(profile, 'userChromeExtensions') || [];
-    const allExtensions = [...chromeExtensions, ...userChromeExtensions];
-
-    if (allExtensions.length) {
-      const ExtensionsManagerInst = new ExtensionsManager();
-      ExtensionsManagerInst.apiUrl = API_URL;
-      await ExtensionsManagerInst.init()
-        .then(() => ExtensionsManagerInst.updateExtensions())
-        .catch(() => {});
-      ExtensionsManagerInst.accessToken = this.access_token;
-
-      await ExtensionsManagerInst.getExtensionsPolicies();
-      let profileExtensionsCheckRes = [];
-
-      if (ExtensionsManagerInst.useLocalExtStorage) {
-        const promises = [
-          ExtensionsManagerInst.checkChromeExtensions(allExtensions)
-            .then(res => ({ profileExtensionsCheckRes: res }))
-            .catch((e) => {
-              console.log('checkChromeExtensions error: ', e);
-
-              return { profileExtensionsCheckRes: [] };
-            }),
-          ExtensionsManagerInst.checkLocalUserChromeExtensions(userChromeExtensions, this.profile_id)
-            .then(res => ({ profileUserExtensionsCheckRes: res }))
-            .catch((error) => {
-              console.log('checkUserChromeExtensions error: ', error);
-
-              return null;
-            }),
-        ];
-
-        const extensionsResult = await Promise.all(promises);
-
-        const profileExtensionPathRes = extensionsResult.find(el => 'profileExtensionsCheckRes' in el) || {};
-        const profileUserExtensionPathRes = extensionsResult.find(el => 'profileUserExtensionsCheckRes' in el);
-        profileExtensionsCheckRes =
-          (profileExtensionPathRes?.profileExtensionsCheckRes || []).concat(profileUserExtensionPathRes?.profileUserExtensionsCheckRes || []);
-      }
-
-      let extSettings;
-      if (ExtensionsManagerInst.useLocalExtStorage) {
-        extSettings = await setExtPathsAndRemoveDeleted(preferences, profileExtensionsCheckRes, this.profile_id);
-      } else {
-        const originalExtensionsFolder = join(profilePath, 'Default', 'Extensions');
-        extSettings = await setOriginalExtPaths(preferences, originalExtensionsFolder);
-      }
-
-      this.extensionPathsToInstall =
-        ExtensionsManagerInst.getExtensionsToInstall(extSettings, profileExtensionsCheckRes);
-
-      if (extSettings) {
-        const currentExtSettings = preferences.extensions || {};
-        currentExtSettings.settings = extSettings;
-        preferences.extensions = currentExtSettings;
-      }
-    }
-
     if (proxy.mode === 'gologin' || proxy.mode === 'tor') {
       const autoProxyServer = get(profile, 'autoProxyServer');
       const splittedAutoProxyServer = autoProxyServer.split('://');
@@ -608,23 +516,38 @@ export class GoLogin {
 
     this.proxy = proxy;
 
-    await this.getTimeZone(proxy).catch((e) => {
-      console.error('Proxy Error. Check it and try again.');
-      throw new Error(`Proxy Error. ${e.message}`);
-    });
-
-    const gologin = this.getGologinPreferences(profile);
+    await Promise.all([
+      this.resolveProfileBrowserVersion(profile),
+      this.initProfileStorage({ profile, local }),
+      this.getTimeZone(proxy).catch((e) => {
+        console.error('Proxy Error. Check it and try again.');
+        throw new Error(`Proxy Error. ${e.message}`);
+      }),
+      this.initCookiesFile(profile),
+    ]);
 
-    debug(`Writing profile for screenWidth ${profilePath}`, JSON.stringify(gologin));
-    gologin.screenWidth = this.resolution.width;
-    gologin.screenHeight = this.resolution.height;
-    debug('writeCookiesFromServer', this.writeCookiesFromServer);
-    this.cookiesFilePath = await getCookiesFilePath(this.profile_id, this.tmpdir);
+    await _promises.rm(join(profilePath, 'Default', 'Sync Data'), { recursive: true }).catch(() => null);
+    const pref_file_name = join(profilePath, 'Default', 'Preferences');
+    debug('reading', pref_file_name);
 
-    if (this.writeCookiesFromServer) {
-      await this.writeCookiesToFile(profile.cookies?.cookies);
+    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, '{}');
     }
 
+    const preferences_raw = await readFile(pref_file_name);
+    const preferences = JSON.parse(preferences_raw.toString());
+    const chromeExtensions = get(profile, 'chromeExtensions') || [];
+    const userChromeExtensions = get(profile, 'userChromeExtensions') || [];
+    const allExtensions = [...chromeExtensions, ...userChromeExtensions];
+
+    const [, orbitaParamsToken] = await Promise.all([
+      this.setupProfileExtensions({ preferences, allExtensions, userChromeExtensions, profilePath }),
+      this.fetchOrbitaParamsToken(profile),
+    ]);
+
     if (this.fontsMasking) {
       const families = fonts?.families || [];
       if (!families.length) {
@@ -632,7 +555,8 @@ export class GoLogin {
       }
 
       try {
-        await composeFonts(families, profilePath, this.differentOs);
+        // TODO: uncomment this when fonts will be fixed
+        // await composeFonts(families, profilePath, this.differentOs);
       } catch (e) {
         console.trace(e);
       }
@@ -642,20 +566,20 @@ export class GoLogin {
       preferences.gologin = {};
     }
 
+    const gologin = this.getGologinPreferences(profile);
+
+    debug(`Writing profile for screenWidth ${profilePath}`, JSON.stringify(gologin));
+    gologin.screenWidth = this.resolution.width;
+    gologin.screenHeight = this.resolution.height;
+    debug('writeCookiesFromServer', this.writeCookiesFromServer);
+
     const isMAC = OS_PLATFORM === 'darwin';
     const checkAutoLangResult = checkAutoLang(gologin, this._tz, profile.autoLang);
     const intlConfig = getIntlProfileConfig(profile, this._tz, profile.autoLang);
 
-    let orbitaParamsToken = '';
-    if (profile.securedOrbitaVersion && (this.browserMajorVersion >= profile.securedOrbitaVersion)) {
-      const tokenRes = await this.requestOrbitaProfileParamsToken(this.profile_id);
-
-      orbitaParamsToken = tokenRes.token;
-    }
-
     this.browserLang = isMAC ? 'en-US' : checkAutoLangResult;
     const prefsToWrite = Object.assign(preferences, { gologin });
-    if (this.browserMajorVersion >= this.newProxyOrbbitaMajorVersion && this.proxy?.mode !== 'none') {
+    if (this.browserMajorVersion >= this.newProxyOrbitaMajorVersion && this.proxy?.mode !== 'none') {
       prefsToWrite.proxy = {
         mode: 'fixed_servers',
         server: gologin.proxy.server,
@@ -666,6 +590,7 @@ export class GoLogin {
     const orbitaConfig = {
       intl: intlConfig,
       gologin: {
+        api_domain: API_URL,
         profile_token: orbitaParamsToken,
         ...clientGologinOpts,
       },
@@ -678,12 +603,141 @@ export class GoLogin {
     const bookmarksFromDb = profile.bookmarks?.bookmark_bar;
     bookmarksParsedData.roots = bookmarksFromDb ? profile.bookmarks : bookmarksParsedData.roots;
     await writeFile(this.bookmarksFilePath, JSON.stringify(bookmarksParsedData));
-
     debug('Profile ready. Path: ', profilePath, 'PROXY', JSON.stringify(get(preferences, 'gologin.proxy')));
 
     return profilePath;
   }
 
+  async resolveProfileBrowserVersion(profile) {
+    if (!this.executablePath) {
+      const { userAgent } = profile.navigator;
+      try {
+        const [browserMajorVersion] = userAgent.split('Chrome/')[1].split('.');
+        this.browserMajorVersion = Number(browserMajorVersion);
+        await this.checkBrowser(browserMajorVersion);
+      } catch (e) {
+        const latestVersionNumber = await this.getLatestBrowserVersion();
+        this.browserMajorVersion = latestVersionNumber;
+        await this.checkBrowser(latestVersionNumber);
+      }
+
+      return;
+    }
+
+    if (!this.browserMajorVersion) {
+      const { userAgent } = profile.navigator;
+      const [browserMajorVersion] = userAgent.split('Chrome/')[1].split('.');
+      this.browserMajorVersion = Number(browserMajorVersion);
+
+      let executableDir = join(this.executablePath, '..');
+      if (OS_PLATFORM === 'darwin') {
+        executableDir = join(this.executablePath, '..', '..', '..');
+      }
+
+      const versionFilePath = join(executableDir, 'version');
+      try {
+        await access(versionFilePath);
+        const versionContent = await readFile(versionFilePath, 'utf8');
+        const versionFromFile = versionContent.trim();
+        const isValidVersion = /^\d+\.\d+\.\d+/.test(versionFromFile);
+        if (isValidVersion) {
+          const [browserMajorVersion] = isValidVersion.split('.');
+          this.browserMajorVersion = Number(browserMajorVersion);
+        }
+      } catch (error) {
+        console.warn('Error reading version file:', error);
+      }
+    }
+  }
+
+  async initProfileStorage({ profile, local }) {
+    if (profile.storageInfo.isNewProfile) {
+      this.isFirstSession = true;
+      await this.createZeroProfile(profile.createCookiesTableQuery);
+
+      return;
+    }
+
+    this.isFirstSession = false;
+    await this.downloadProfileAndExtract(profile, local);
+  }
+
+  async initCookiesFile(profile) {
+    this.cookiesFilePath = await getCookiesFilePath(this.profile_id, this.tmpdir);
+    if (this.writeCookiesFromServer) {
+      await this.writeCookiesToFile(profile.cookies?.cookies);
+    }
+  }
+
+  async setupProfileExtensions({ preferences, allExtensions, userChromeExtensions, profilePath }) {
+    if (!allExtensions.length) {
+      return;
+    }
+
+    const ExtensionsManagerInst = new ExtensionsManager();
+    ExtensionsManagerInst.apiUrl = API_URL;
+    await ExtensionsManagerInst.init()
+      .then(() => ExtensionsManagerInst.updateExtensions())
+      .catch(() => {});
+    ExtensionsManagerInst.accessToken = this.access_token;
+
+    await ExtensionsManagerInst.getExtensionsPolicies();
+    let profileExtensionsCheckRes = [];
+
+    if (ExtensionsManagerInst.useLocalExtStorage) {
+      const promises = [
+        ExtensionsManagerInst.checkChromeExtensions(allExtensions)
+          .then(res => ({ profileExtensionsCheckRes: res }))
+          .catch((e) => {
+            console.log('checkChromeExtensions error: ', e);
+
+            return { profileExtensionsCheckRes: [] };
+          }),
+        ExtensionsManagerInst.checkLocalUserChromeExtensions(userChromeExtensions, this.profile_id)
+          .then(res => ({ profileUserExtensionsCheckRes: res }))
+          .catch((error) => {
+            console.log('checkUserChromeExtensions error: ', error);
+
+            return null;
+          }),
+      ];
+
+      const extensionsResult = await Promise.all(promises);
+
+      const profileExtensionPathRes = extensionsResult.find(el => 'profileExtensionsCheckRes' in el) || {};
+      const profileUserExtensionPathRes = extensionsResult.find(el => 'profileUserExtensionsCheckRes' in el);
+      profileExtensionsCheckRes =
+        (profileExtensionPathRes?.profileExtensionsCheckRes || []).concat(profileUserExtensionPathRes?.profileUserExtensionsCheckRes || []);
+    }
+
+    let extSettings;
+    if (ExtensionsManagerInst.useLocalExtStorage) {
+      extSettings = await setExtPathsAndRemoveDeleted(preferences, profileExtensionsCheckRes, this.profile_id);
+    } else {
+      const originalExtensionsFolder = join(profilePath, 'Default', 'Extensions');
+      extSettings = await setOriginalExtPaths(preferences, originalExtensionsFolder);
+    }
+
+    this.extensionPathsToInstall =
+      ExtensionsManagerInst.getExtensionsToInstall(extSettings, profileExtensionsCheckRes);
+
+    if (extSettings) {
+      const currentExtSettings = preferences.extensions || {};
+      currentExtSettings.settings = extSettings;
+      preferences.extensions = currentExtSettings;
+    }
+  }
+
+  async fetchOrbitaParamsToken(profile) {
+    if (!profile.securedOrbitaVersion || this.browserMajorVersion < profile.securedOrbitaVersion) {
+      return '';
+    }
+
+    const tokenRes = await this.requestOrbitaProfileParamsToken(this.profile_id);
+
+    return tokenRes.token;
+  }
+
   async commitProfile() {
     // wait for orbita to finish working with files
     await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -760,6 +814,14 @@ export class GoLogin {
       return this._tz.timezone;
     }
 
+    if (this._tz) {
+      debug('getTimeZone from cache', this._tz.timezone);
+
+      return this._tz.timezone;
+    }
+
+    const isGologinProxy = proxy?.host?.includes('floppydata.com');
+
     let data = null;
     if (proxy && proxy.mode !== PROXY_NONE) {
       if (proxy.mode.includes('socks')) {
@@ -772,7 +834,7 @@ export class GoLogin {
             console.log(e.message);
           }
         }
-        throw new Error('Socks proxy connection timed out');
+        throw new Error(`Proxy Error${isGologinProxy ? ' (Gologin)' : ''}`);
       }
 
       const proxyUrl = `${proxy.mode}://${proxy.username}:${proxy.password}@${proxy.host}:${proxy.port}`;
@@ -783,6 +845,8 @@ export class GoLogin {
         timeout: this.proxyCheckTimeout,
         maxAttempts: this.proxyCheckAttempts,
         method: 'GET',
+      }).catch((e) => {
+        throw new Error(`${e.message}${isGologinProxy ? ' (Gologin)' : ''}`);
       });
     } else {
       data = await makeRequest(TIMEZONE_URL, { timeout: this.proxyCheckTimeout, maxAttempts: this.proxyCheckAttempts, method: 'GET' });
@@ -828,7 +892,9 @@ export class GoLogin {
     proxy += host + ':' + port;
     const agent = new SocksProxyAgent(proxy);
 
-    const checkData = await checkSocksProxy(agent);
+    const checkData = await checkSocksProxy(agent).catch((e) => {
+      throw new Error(`Proxy Error. ${e.message}`);
+    });
 
     const body = checkData.body || {};
     if (!body.ip && checkData.statusCode.toString().startsWith('4')) {
@@ -912,6 +978,7 @@ export class GoLogin {
 
     const ORBITA_BROWSER = this.executablePath || this.browserChecker.getOrbitaPath;
     debug(`ORBITA_BROWSER=${ORBITA_BROWSER}`);
+
     const env = {};
     Object.keys(process.env).forEach((key) => {
       env[key] = process.env[key];
@@ -977,7 +1044,7 @@ export class GoLogin {
         params.push(`--host-resolver-rules=${hr_rules}`);
       }
 
-      if (proxy && Number(this.browserMajorVersion) < this.newProxyOrbbitaMajorVersion) {
+      if (proxy && Number(this.browserMajorVersion) < this.newProxyOrbitaMajorVersion) {
         params.push(`--proxy-server=${proxy}`);
       }
 
@@ -1002,7 +1069,7 @@ export class GoLogin {
       debug('GETTING WS URL FROM BROWSER');
       const data = await makeRequest(
         `http://127.0.0.1:${remote_debugging_port}/json/version`,
-        { json: true, maxAttempts: 30, retryDelay: 1000, method: 'GET' },
+        { json: true, maxAttempts: 30, retryDelay: 400, method: 'GET' },
       );
 
       debug('WS IS', get(data, 'webSocketDebuggerUrl', ''));
@@ -1428,6 +1495,7 @@ export class GoLogin {
 
   async startLocal() {
     await this.createStartup(true);
+
     // await this.createBrowserExtension();
     const startResponse = await this.spawnBrowser();
     this.setActive(true);

package/src/utils/http.js

@@ -33,7 +33,7 @@ const attemptRequest = async (requestUrl, options) => {
   return req.body;
 };
 
-export const makeRequest = async (url, options, internalOptions) => {
+export const makeRequest = async (url, options = {}, internalOptions) => {
   options.headers = {
     ...options.headers,
     'User-Agent': `gologin-nodejs-sdk/${version}`,