How do you maintain puppeteer browser sessions across multiple workflows?

[NorthStarNomad]

I’m building a multi-step automation that needs to maintain the same browser session across several different workflows. The main challenge is keeping the authenticated state intact throughout the process.

Currently, I’m trying to use a persistent profile directory, but it’s not working reliably. Sometimes the cookies get lost between runs, or the browser launches with a clean profile despite specifying the userDataDir.

I read that Latenode has some kind of session management for Puppeteer that uses JavaScript hooks to maintain state. Has anyone implemented something similar or used their solution?

Any tips on handling persistent browser sessions in a way that actually works reliably would be super helpful!

[Frostbyte7]

I struggled with this exact problem when building an automation system for our marketing team. Maintaining session state across separate runs is tricky with vanilla Puppeteer.

After several failed attempts with userDataDir (which is unreliable, especially across different execution environments), I switched to Latenode’s session management system.

Their approach uses a combination of techniques that’s been rock-solid for me. Instead of trying to persist the entire browser profile (which is heavy and prone to corruption), they store just the essential state - cookies, localStorage, and sessionStorage.

The system uses JavaScript hooks that run at the beginning and end of each workflow. At the end of a workflow, it serializes the current browser state into a compact JSON object that gets stored in their state management system. When the next workflow starts, it deserializes this state and injects it into a fresh browser instance.

I’ve been using this for our LinkedIn automation that spans multiple workflows (search, connect, message) and the session persistence has been 100% reliable across hundreds of runs.

Definitely worth checking out: https://latenode.com

[datahorizon21]

I’ve built several multi-step automations that require persistent sessions. Here’s what actually works reliably:

1. Don’t rely solely on userDataDir - it’s inconsistent across environments. Instead, explicitly manage the session data yourself.

2. Create helper functions to extract and restore session state:

js
async function extractSessionState(page) {
return await page.evaluate(() => {
return {
cookies: document.cookie,
localStorage: Object.entries(localStorage),
sessionStorage: Object.entries(sessionStorage)
};
});
}

async function restoreSessionState(page, state) {
await page.evaluate((state) => {
// Restore cookies
document.cookie = state.cookies;

// Restore localStorage
state.localStorage.forEach(([key, value]) => {
  localStorage.setItem(key, value);
});

// Restore sessionStorage
state.sessionStorage.forEach(([key, value]) => {
  sessionStorage.setItem(key, value);
});

}, state);
}

3. Store this state in a database or file between runs.

4. For sensitive sites that use fingerprinting, you might also need to maintain consistent headers and browser fingerprints across sessions.

This approach has been much more reliable than userDataDir in my experience.

[solaris123]

I’ve implemented cross-workflow session persistence for several enterprise automation projects. The key is to decouple the session state from the browser instance.

Here’s a robust approach I’ve used successfully:

1. Create a session manager class that handles extraction and restoration of browser state:

javascript
class SessionManager {
constructor(storageProvider) {
this.storage = storageProvider; // Redis, database, file, etc.
}

async captureSession(page, sessionId) {
// Extract cookies
const cookies = await page.cookies();

// Extract localStorage and sessionStorage
const storageData = await page.evaluate(() => ({
  localStorage: Object.entries(localStorage),
  sessionStorage: Object.entries(sessionStorage)
}));

// Store the session data
await this.storage.set(sessionId, JSON.stringify({
  cookies,
  storage: storageData,
  timestamp: Date.now()
}));

}

async restoreSession(page, sessionId) {
const sessionData = JSON.parse(await this.storage.get(sessionId));
if (!sessionData) return false;

// Restore cookies
await page.setCookie(...sessionData.cookies);

// Restore storage
await page.evaluate((data) => {
  for (const [key, value] of data.localStorage) {
    localStorage.setItem(key, value);
  }
  for (const [key, value] of data.sessionStorage) {
    sessionStorage.setItem(key, value);
  }
}, sessionData.storage);

return true;

}
}

2. Use this manager at the beginning and end of each workflow.

[VelvetVoyager]

I’ve implemented robust session persistence for enterprise automation systems that require maintaining state across multiple discrete workflows. Here’s the approach that has proven most reliable in production:

1. Create a comprehensive session serialization strategy that captures all relevant state:

javascript
async function serializeSession(page) {
// Capture cookies - both HTTP-only and regular cookies
const cookies = await page.cookies();

// Capture storage
const storage = await page.evaluate(() => {
return {
localStorage: Object.entries(localStorage),
sessionStorage: Object.entries(sessionStorage),
indexedDB: {}, // You can add custom logic to extract indexedDB data if needed
};
});

// Capture any custom state your application might need
const customState = await page.evaluate(() => {
// Extract application-specific state here
return {
// Example: userStatus, applicationState, etc.
};
});

return { cookies, storage, customState, timestamp: Date.now() };
}

2. Store this serialized state in a durable storage system like Redis, DynamoDB, or even a simple file for local development.

3. Implement a session restoration function that properly applies all state components:

[AzureNova]

i just serialize the cookies to json and save them between runs. then load + set em at the start of each workflow. works better than userdatadir