Recover your old Grammarly Docs

I registered on Grammarly on 2016-05-11T12:49:14.000(I took the date from the API). Since then, Grammerly checked about 1.8M words I wrote which is more or less ~17 novels.

As a non-native English speaker, I generally use Grammarly to at least get rid of any typos.

Not all the checkings were made over Docs in the app since Grammarly has extensions and can check in many other places.

But in the app, I created around ~600 documents unfortunately, Grammarly does not support pagination, and it only shows the last most recently accessed 100 docs.

But their API can list a lot more than that probably over 5k docs, maybe even more, in fact, I don't think they even delete any doc you write even if you previously deleted it because you can find this flag on their API filterDocs=not_deleted.

Anyway, their listing uses REST, but their actual document interactions are done over WebSockets.

So I made a basic script that will allow you to get all documents from your Grammarly, you only need to pass your cookie in the env file.

It's recommended to run this script with Bun.js but might work with Node too.

I had to use node lib for WS since Bun's implementation of Web Sockets as of now doesn't support setting headers.

First, here is a link to the repo containing this script, this will make it easier to get the code:
https://bitbucket.org/andrei0x309/grammarly-doc-recovery/src/main/

But I will also provide the script here in one file in case the link will not be available later:

import fs from 'fs'
import WebSocketNode from 'ws';

// config
const limitNumDocs = 5000 // limit the number of documents to export default grammarly uses is 100 (last 100 docs)
const exportPath = './export'
const delayBetweenDocs = 350 // delay between each document export in milliseconds
const stopAtDateBefore = new Date('2015-01-01') // stop exporting documents before this date
// /config

// code

// Types
type DocFromList =  {
    id:            number;
    user_id:       number;
    title:         string;
    size:          number;
    first_content: string;
    errors:        number;
    created_at:    Date;
    updated_at:    Date;
    is_deleted:    number;
    extra_params:  ExtraParams;
}

export interface ExtraParams {
    context: Context;
}

export interface Context {
    dialect: string;
}


export interface WsDocFile {
    doc:          Doc;
    doc_len:      number;
    vsn:          number;
    title:        string;
    errors:       number;
    created_at:   Date;
    extra_params: ExtraParams;
    clientId:     number;
    op:           string;
}

export interface Doc {
    ops: Op[];
}

export interface Op {
    insert: string;
}

export interface ExtraParams {
    context: Context;
}

export interface Context {
    dialect: string;
}
// /Types

// Logic
const GRAMMARLY_COOKIE = process.env.GRAMMARLY_COOKIE
const API_BASE = 'https://dox.grammarly.com/'
const WSS_BASE = 'wss://dox.grammarly.com/'

if(!GRAMMARLY_COOKIE) {
    throw new Error('GRAMMARLY_COOKIE is not defined, please set it in .env file')
}

// check if the export folder exists
if(!fs.existsSync(exportPath)) {
    fs.mkdirSync(exportPath)
}

if (limitNumDocs < 100) {
    throw new Error('limitNumDocs must be greater than 100')
}

const getCookieByKey = (key: string) => {
    const cookies = GRAMMARLY_COOKIE.split(';')
    const cookie = cookies.find(cookie => cookie.includes(key))
    return cookie?.split?.('=')?.[1]
}

const createHeader = () => {

    const containerId = getCookieByKey('gnar_containerId') ?? 'ewle98uqofe30200'
    const crfsToken = getCookieByKey('csrf-token') ?? 'AABOwIV4gYQL/cTy1IuFNELaLQ02GMpwcQL08g'

    return {
        'Content-Type': 'application/json',
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36',
        'Cookie': GRAMMARLY_COOKIE,
        'Origin': 'https://app.grammarly.com',
        'Referer': 'https://app.grammarly.com/',
        'x-api-version': '2',
        'x-client-type': 'denali_editor',
        'x-client-version': '1.5.43-6524+master',
        'x-container-id': containerId,
        'x-csrf-token': crfsToken,
    }
}

const HEADERS = createHeader()

const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))

const getDocsList = async () => {
    const req = await fetch(`${API_BASE}documents?search=&limit=${limitNumDocs}&firstCall=false&filterDocs=not_deleted`, {
        method: 'GET',
        headers: HEADERS,
    })

    if(!req.ok) {
        throw new Error(`Error getting docs list: ${req.status}`)
    }

    return await req.json() as DocFromList[]
}

const getSoketHeader = () => {
    return {
        'Accept-Encoding': 'gzip, deflate, br',
        'Accept-Language': 'en-US,en;q=0.9',
        'Connection': 'Upgrade',
        'Cookie': GRAMMARLY_COOKIE,
        'Host': 'dox.grammarly.com',
        'Origin': 'https://app.grammarly.com',
        'Pragma': 'no-cache',
        'Upgrade': 'websocket',
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36',
    }
}

const exportDocs = async () => {
    const docs = await getDocsList()
    const numOfDocs = docs.length
    let progress = 0
    const MaximumWsConnections = 10
    let wsConnectionsCount = 0
    const WaitBackOff = 2000

    for (let i = 0; i < numOfDocs; i++) {
        const doc = docs[i]
        console.log(`Exporting doc: ${doc.id}`)

        if (wsConnectionsCount >= MaximumWsConnections) {
            await wait(WaitBackOff)
            console.log(`Allowed connections reached, waiting for connections to close`)
            i-=1
            continue
        }

        if(new Date(doc.created_at).getTime() < stopAtDateBefore.getTime()) {
            console.log(`Doc ${doc.id} is older than ${stopAtDateBefore.toISOString()}, stopping export`)
            process.exit(0)
        }

        const socket = new WebSocketNode(`${WSS_BASE}documents/${doc.id}/ws`, 
            {
                headers: getSoketHeader(),
            })
        
        wsConnectionsCount++

        socket.addEventListener("error", event => {
          console.error(event);
          if(wsConnectionsCount > 0) {
            wsConnectionsCount--
          }
        })

        socket.addEventListener("message", event => {
           const data = JSON.parse(event.data.toString()) as WsDocFile
           const title = `${new Date(doc.created_at).toISOString().split('T')[0]} - ${doc.id}.txt`
           const content = data.doc.ops.map(op => op.insert).join('')
           fs.writeFileSync(`${exportPath}/${title}`, content)
           progress++
           console.log(`Exported doc: ${doc.id}, ${progress}/${numOfDocs}`)
           socket.close()
           if(wsConnectionsCount > 0) {
            wsConnectionsCount--
          }
        })
        await wait(delayBetweenDocs)
    }
    console.log('Exported all docs')
}
// /Logic

// Execution
exportDocs()

In the repo, you'll also find other things in the Readme.md.
If you execute the script, provided you did add your cookie the outpost should look like this:

Documents will be exported in the folder export, where you execute the script.
Hope this will help you get your docs.

Also if you use another product that you think is better than Grammarly please tell me, I've been using Grammarly for so long, and I haven't tried many other alternatives.

I feel like the free plan could offer a bit more.