NAME

overleaf - command-line client for Webservice::Overleaf::API

SYNOPSIS

overleaf [global-options] COMMAND [command-arguments]

overleaf --help
overleaf --version

overleaf project-url PROJECT_ID
overleaf git-url PROJECT_ID

overleaf open-uri URL
overleaf open-uri --engine lualatex --main-document main.tex URL
overleaf open-data paper.tex
overleaf snippet-form paper.tex

overleaf clone PROJECT_ID DIRECTORY
overleaf pull DIRECTORY
overleaf push DIRECTORY
overleaf remote-add DIRECTORY PROJECT_ID [REMOTE]

overleaf --experimental projects
overleaf --experimental bootstrap
overleaf --experimental zip PROJECT_ID
overleaf --experimental compile PROJECT_ID
overleaf --experimental compile
overleaf --experimental compile main.tex
overleaf --experimental pdf PROJECT_ID
overleaf --experimental output PROJECT_ID output.log

DESCRIPTION

overleaf is the command-line companion to Webservice::Overleaf::API.

It exposes the supported Overleaf import and Git integration surfaces as well as the module's explicitly opt-in experimental browser-session operations.

The program is implemented as a modulino. Loading bin/overleaf from a test or another Perl program does not invoke main() automatically.

The official/supported operations are URL generation, Open in Overleaf import helpers, and the Overleaf Git bridge. Project listing, ZIP download, remote compilation, PDF retrieval, and compile-output retrieval use undocumented Overleaf web-application interfaces and therefore require --experimental.

COMMANDS

project-url PROJECT_ID

Print the normal browser/editor URL for an Overleaf project.

git-url PROJECT_ID

Print the Overleaf Git bridge remote URL for a project.

open-uri URL [URL ...]

Generate an Open in Overleaf URL for one or more remote TeX or ZIP resources.

Relevant options are --engine, --main-document, --visual-editor/--no-visual-editor, and repeatable --name.

open-data FILE

Read FILE and generate an Open in Overleaf data URI.

--mime defaults in the API to application/x-tex. Use an appropriate MIME type when importing other content, such as a ZIP archive.

snippet-form FILE

Read FILE as a TeX snippet and print a complete HTML form that POSTs the snippet to Overleaf. The generated form includes an Open in Overleaf submit button.

clone PROJECT_ID DIRECTORY

Clone the project's official Overleaf Git remote into DIRECTORY.

Authentication is handled by Git itself. The client does not place Git credentials or tokens in the remote URL.

pull DIRECTORY

Run git -C DIRECTORY pull through the API client's Git runner.

push DIRECTORY

Run git -C DIRECTORY push through the API client's Git runner.

remote-add DIRECTORY PROJECT_ID [REMOTE]

Add an Overleaf Git remote to an existing repository.

REMOTE defaults to overleaf. --remote NAME is an alternative to the optional positional REMOTE argument.

bootstrap

Validate the configured browser session and obtain the CSRF state required by experimental web-application calls.

For safety, the CSRF token is not printed. A successful bootstrap prints:

authenticated

Requires --experimental and a browser-session credential.

projects

List active projects as tab-separated records:

PROJECT_ID    NAME    LAST_UPDATED

Archived and trashed projects are omitted by the API client.

Requires --experimental and a browser-session credential.

zip PROJECT_ID

Download the full project ZIP.

The default output filename is PROJECT_ID.zip. Override it with --output.

Requires --experimental and a browser-session credential.

compile PROJECT_ID

Trigger a low-level Overleaf compile of the named remote project and print the resulting status, PDF URL, and reported compile outputs as tab-separated records. This is the behavior provided by earlier releases.

Use --resource-path FILE to request a specific root resource.

compile [ROOT.tex]

When invoked from inside a local Git checkout connected to an Overleaf Git remote, compile also has a higher-level project workflow:

overleaf --experimental compile main.tex

The client finds the repository root, discovers the Overleaf project ID and remote branch from the Git checkout, verifies that the work tree is clean, pushes the complete committed project as HEAD:REMOTE_BRANCH, remotely compiles main.tex, and downloads the PDF as main.pdf.

The remote branch is discovered from the current branch's upstream or the remote HEAD recorded by Git. The client intentionally does not hard-code master or main. Use --remote-branch NAME when a repository does not contain enough local remote metadata for automatic discovery.

Omit ROOT.tex to use the root document configured on Overleaf:

overleaf --experimental compile

In that case the default local PDF name is based on the repository directory. --output FILE always overrides the local PDF filename.

This workflow intentionally synchronizes the Git project, not selected file extensions. A TeX root may depend on .tex, .bib, .sty, .cls, image, source-code, or other project files. The project ZIP is an export/snapshot and is not used as the editable source for this operation.

By default a dirty work tree is rejected rather than silently committing or omitting local work, and an explicitly requested root must be tracked by Git. If Overleaf has newer web-editor changes and Git rejects the push as non-fast-forward, pull and reconcile them normally; overleaf deliberately does not rewrite or merge the local history. --no-push skips synchronization and compiles the existing Overleaf project state while still using the Git remote to discover the project ID.

Use --remote NAME if more than one Overleaf Git remote is configured or if a specific remote should be selected.

Both forms require --experimental and a browser-session credential for the compile/download phase. The push phase separately uses an Overleaf Git token. By default the CLI discovers ~/.overleaf/session and ~/.overleaf/git-token; see "AUTHENTICATION".

pdf PROJECT_ID

Compile the project and download the generated PDF.

The default output filename is PROJECT_ID.pdf. Override it with --output.

Use --resource-path FILE to request a specific root resource.

Requires --experimental and a browser-session credential.

output PROJECT_ID PATH

Compile the project and download one named compile artifact, for example:

overleaf --experimental output PROJECT_ID output.log
overleaf --experimental output PROJECT_ID output.bbl
overleaf --experimental output PROJECT_ID output.aux

The default local filename is the basename of PATH. Override it with --output.

Requires --experimental and a browser-session credential.

help

Display the full manual.

OPTIONS

-h, --help

Display the full manual and exit successfully.

-v, --version

Print the command name and the installed Webservice::Overleaf::API version.

--experimental

Enable methods backed by Overleaf's undocumented browser web-application interface.

This option is required for bootstrap, projects, zip, compile, pdf, and output.

--session VALUE

Supply the Overleaf browser-session cookie value directly.

Using OVERLEAF_SESSION or --session-file is preferable because command arguments may be visible to other users on the same machine.

--session-file FILE

Read the Overleaf browser-session cookie value from FILE.

Credential files read by the client must be stored under ~/.overleaf/. They should be created with mode 0600, which the client verifies wherever the filesystem exposes enforceable POSIX modes. The standard session file is ~/.overleaf/session, which is discovered automatically when neither --session, --session-file, nor OVERLEAF_SESSION supplies a session. The file contains only the value of the overleaf_session2 cookie on one line; do not include overleaf_session2=.

--git-token-file FILE

Read the Overleaf Git authentication token from FILE. The file must be under ~/.overleaf/ and should be created with mode 0600; exact mode is verified where POSIX permissions are enforceable. The standard file is ~/.overleaf/git-token, which is discovered automatically when --git-token-file and OVERLEAF_GIT_TOKEN are not set.

The token is supplied to Git through a temporary GIT_ASKPASS helper with the documented username git; it is not embedded in the Git remote URL or Git command arguments.

--remote-branch NAME

Override the remote branch used by the high-level local compile [ROOT.tex] workflow. Normally the client discovers the branch from the current branch's upstream or the selected remote's recorded HEAD. This avoids assuming that a particular Overleaf project uses master or main.

--csrf VALUE

Supply a previously obtained CSRF token. Normally the client bootstraps one from the Overleaf project page when needed.

--base-url URL

Override the Overleaf base URL. The default is:

https://www.overleaf.com

This is useful with self-hosted Overleaf installations.

--git-base-url URL

Override the Git bridge base URL.

For Overleaf Cloud the default is:

https://git.overleaf.com

Override the browser-session cookie name.

The default is overleaf_session2.

--timeout SECONDS

Set the HTTP timeout.

--engine ENGINE

Set the TeX engine for Open in Overleaf imports.

Supported values are:

latex_dvipdf
pdflatex
xelatex
lualatex

--main-document FILE

Specify the main document for Open in Overleaf imports.

--visual-editor, --no-visual-editor

Request or disable the Overleaf Visual Editor for Open in Overleaf imports.

--name NAME

Specify an imported filename for open-uri or open-data.

The option may be repeated when importing multiple URIs.

--mime TYPE

Set the MIME type used by open-data.

-o FILE, --output FILE

Set the local output filename for zip, pdf, output, or the higher-level local compile [ROOT.tex] workflow.

--resource-path FILE

Request a specific root resource for compile, pdf, or output.

--remote NAME

Set the remote name used by remote-add, or select the Overleaf Git remote used by local compile [ROOT.tex].

--push, --no-push

Local compile [ROOT.tex] pushes the clean committed Git project to Overleaf by default. --no-push skips synchronization and compiles the project state already present on Overleaf.

AUTHENTICATION

Why two credentials?

Overleaf splits the functionality used by this client across two different authentication systems. This is important when troubleshooting the CLI:

Browser-session credential

Used by the Overleaf web-application operations: bootstrap, projects, zip, remote compile, pdf, and output. The credential is the value of the browser cookie named overleaf_session2.
Git authentication token

Used by the official Git bridge for clone, pull, push, and the Git synchronization phase of the high-level local compile [ROOT.tex] workflow. The Git username is git; the token is the password.

A normal local compile main.tex with pushing enabled uses both: the Git token first synchronizes the committed project, then the browser session asks Overleaf to compile it and downloads the resulting PDF. --no-push skips the Git step and therefore needs only the browser session.

Standard credential directory

For ordinary use, overleaf standardizes both credentials under one private per-user directory:

~/.overleaf/session
~/.overleaf/git-token

Create it once:

mkdir -p ~/.overleaf
chmod 700 ~/.overleaf

The intended credential-file mode is 0600:

chmod 600 ~/.overleaf/session
chmod 600 ~/.overleaf/git-token

On POSIX filesystems where Unix permission bits are meaningful, overleaf requires and verifies mode 0600. MSYS2 commonly uses Windows filesystems mounted with noacl; there chmod 600 may succeed while Perl stat() still reports synthetic 0644-style bits. The client detects when the filesystem cannot enforce POSIX mode changes and does not reject a credential solely for those synthetic bits. The files must still be under ~/.overleaf/ and should remain private to the Windows account/ACL that owns them.

Set up the browser session: ~/.overleaf/session

This credential is not an Overleaf API key. It is the authentication cookie from a browser in which you are already logged into Overleaf.

For Firefox:

Log into https://www.overleaf.com/ normally and leave that authenticated browser session open.
Press F12 to open Developer Tools. Select Storage, then Cookies, then https://www.overleaf.com.
Find the cookie named overleaf_session2.
Copy only the cookie's Value. Do not copy the cookie name and do not write overleaf_session2= into the file.

For Chrome, Edge, and other Chromium-family browsers, open Developer Tools, select Application, then Storage, Cookies, and https://www.overleaf.com. Find overleaf_session2 and copy only its Value.

Store that one value on one line:

read -rsp 'Paste overleaf_session2 value: ' OL_SESSION; printf '\n'
printf '%s\n' "$OL_SESSION" > ~/.overleaf/session
unset OL_SESSION
chmod 600 ~/.overleaf/session

Test the browser-session side independently:

overleaf --experimental bootstrap
overleaf --experimental projects

A successful bootstrap prints:

authenticated

Session resolution order is:

1. --session VALUE
2. --session-file FILE
3. OVERLEAF_SESSION
4. ~/.overleaf/session

OVERLEAF_SESSION is useful for ephemeral automation when populated by a secret manager or parent process. Avoid typing the credential literally into a command that will be retained in shell history.

--session VALUE remains available for compatibility, but a protected file or environment variable is preferable because command arguments may appear in process listings or shell history.

Set up the Git token: ~/.overleaf/git-token

The Git bridge does not use overleaf_session2 and does not use your normal Overleaf account password. Current Overleaf Git access requires a Git authentication token.

To create one from your account:

Open Overleaf Account Settings:

https://www.overleaf.com/user/settings
Find the Git authentication tokens section and choose Generate token.
Copy the complete token when Overleaf displays it. Overleaf later shows the list of generated tokens but does not reveal the complete token again. If the value is lost, generate a new token and delete the old one if it is no longer needed.

The first time Git integration is used for a project, Overleaf can also offer token generation from the project itself: open the project, select Integrations, choose Git, and then Generate token when offered.

Overleaf documents the Git username as git. The generated authentication token is used as the password. A token belongs to the user, not to one specific project, so the same token can be used for all projects to which that account has Git access. Overleaf currently documents a one-year token expiry. Never share the token with collaborators; each collaborator should use their own token.

Store only the complete token value:

read -rsp 'Paste Overleaf Git token: ' OL_GIT_TOKEN; printf '\n'
printf '%s\n' "$OL_GIT_TOKEN" > ~/.overleaf/git-token
unset OL_GIT_TOKEN
chmod 600 ~/.overleaf/git-token

Test the Git side independently with a project you can access:

ID=0123456789abcdef
overleaf clone "$ID" my-paper

With ~/.overleaf/git-token configured, the client supplies username git and the token through a temporary GIT_ASKPASS helper. The token is not placed in the repository URL, .git/config, shell history, or Git command arguments.

Git-token resolution order is:

1. --git-token-file FILE
2. OVERLEAF_GIT_TOKEN
3. ~/.overleaf/git-token
4. normal Git credential handling/prompting if no token is configured

OVERLEAF_GIT_TOKEN is also supported for automation when populated by a secret manager or parent process. Avoid typing the token literally into shell history.

Overleaf's current token instructions are published at:

https://docs.overleaf.com/integrations-and-add-ons/git-integration-and-github-synchronization/git-integration/git-integration-authentication-tokens

Combined authenticated workflow

Once both standard files are configured, the common author/editor workflow no longer needs credential options:

ID=0123456789abcdef

# Uses ~/.overleaf/git-token only.
overleaf clone "$ID" my-paper
cd my-paper

# Edit the project as a Git project, then commit it.
$EDITOR main.tex
git add .
git commit -m 'revise paper'

# Uses the Git token to push, then ~/.overleaf/session to compile and
# download the PDF.
overleaf --experimental compile main.tex

# Windows / MSYS2
start main.pdf

# Linux desktop
xdg-open main.pdf >/dev/null 2>&1 &

For a read-only compile test that does not synchronize Git:

overleaf --experimental --no-push compile main.tex

That command needs only the browser session because it compiles the project state already present on Overleaf.

Troubleshooting the two authentication paths

If clone, pull, or the push phase of local compile fails with a Git 403 or an authentication-token error, inspect or regenerate the Git token; replacing the browser session will not fix the Git bridge.

If bootstrap, projects, remote compilation, ZIP download, or PDF/output retrieval reports an expired or failed Overleaf web session, refresh the overleaf_session2 browser-cookie value; replacing the Git token will not fix browser-session authentication.

Session lifetime

As of the Overleaf Cookie Policy last modified 5 August 2026, overleaf_session2 has a documented 5-day retention period. Treat the session file as a short-lived credential and replace its value when browser session authentication stops working.

The five-day period is not a guarantee that a particular value remains valid for exactly five days. Logging out, revocation, rotation, security changes, or other server-side invalidation may end it earlier.

See https://www.overleaf.com/legal for the current cookie policy.

PRACTICAL WALKTHROUGH

This section shows a complete shell workflow, beginning with browser authentication and ending with source inspection, remote compilation, PDF viewing, build-artifact retrieval, and Git interaction.

The 0.06 local compile workflow joins the two useful interfaces together: Git synchronizes the source project, while the browser-session interface asks Overleaf to compile that synchronized project and returns the resulting PDF. The ZIP interface remains useful for export, backup, and inspection, but it is not the normal local editing transport.

Once a project has been cloned through the Git bridge and the session file has been configured, the ordinary edit/build cycle is intentionally short:

cd my-paper
$EDITOR main.tex
git add .
git commit -m 'revise paper'

overleaf --experimental \
    --session-file ~/.overleaf/session \
    compile main.tex

A successful local compile reports the inferred project and remote, pushes the committed project, compiles once, and downloads main.pdf:

project  0123456789abcdef
remote   origin
root     main.tex
source   committed HEAD
push     ok
status   success
saved    main.pdf

On Windows/MSYS2:

start main.pdf

On Linux:

xdg-open main.pdf >/dev/null 2>&1 &

1. Obtain the browser session

The experimental commands use the same authenticated session as the Overleaf web application. Log into https://www.overleaf.com/ normally.

In Firefox:

Press F12 and open Developer Tools.
Select Storage, then Cookies, then https://www.overleaf.com.
Find overleaf_session2.
Copy only its Value.

In Chrome, Edge, or another Chromium-family browser, open Developer Tools, select Application, then Storage, Cookies, and https://www.overleaf.com.

Save only the cookie value in a protected file:

read -rsp 'Paste overleaf_session2 value: ' OL_SESSION; printf '\n'
printf '%s\n' "$OL_SESSION" > ~/.overleaf/session
unset OL_SESSION
chmod 600 ~/.overleaf/session

Do not write:

overleaf_session2=PASTE_COOKIE_VALUE_HERE

The file is just one line containing the cookie value.

The standard path is discovered automatically, so the examples below do not need --session-file. OVERLEAF_SESSION remains available for temporary environment-based use.

Overleaf currently documents a five-day retention period for overleaf_session2. Treat that as an approximate lifetime: logout, revocation, rotation, or server-side invalidation can end a session earlier.

2. Verify the session

Run:

overleaf --experimental \
    bootstrap

Success looks like:

authenticated

If this fails after previously working, obtain a fresh overleaf_session2 value from the browser and replace the contents of ~/.overleaf/session.

3. List projects and choose an ID

List active projects:

overleaf --experimental \
    projects

The output is tab-separated:

PROJECT_ID    PROJECT NAME    LAST_UPDATED

Choose one project and keep its ID in a shell variable:

ID=0123456789abcdef

You can verify the normal browser URL and Git URL without using the session:

overleaf project-url "$ID"
overleaf git-url "$ID"

4. Download and inspect the source project

To inspect the source tree, download the full project ZIP:

overleaf --experimental \
    --output project.zip \
    zip "$ID"

The command prints the saved filename:

project.zip

List everything in the archive:

unzip -l project.zip

Find the TeX source files:

unzip -l project.zip | grep -Ei '\.tex$'

For a larger project this might show a root document and many included files:

user_guide.tex
preface.tex
setup.tex
appendix/basic_commands.tex
appendix/memory_map.tex

To work with the complete source tree locally:

mkdir project-src
cd project-src
unzip ../project.zip

Then:

find . -type f -name '*.tex' -print

zip and compile answer different questions. zip retrieves project source files. compile reports generated build artifacts.

5. Compile the project

Compile using Overleaf's configured root document:

overleaf --experimental \
    compile "$ID"

The first lines look approximately like:

status  success
pdf     https://www.overleaf.com/project/.../output/output.pdf?...

They are followed by generated build artifacts such as:

output  output.aux      aux      ...
output  output.bbl      bbl      ...
output  output.chktex   chktex   ...
output  output.log      log      ...
output  output.pdf      pdf      ...

Packages such as minted may generate many additional entries under paths such as _minted-output/. This is normal. These are build outputs, not source .tex files.

6. Discover the configured root TeX document

If you do not know which .tex file Overleaf is compiling, retrieve output.log:

overleaf --experimental \
    --output output.log \
    output "$ID" output.log

The TeX log normally begins with a line similar to:

**user_guide.tex

A useful shell command is:

grep -m1 '^\*\*[^*]' output.log

The [^*] prevents later diagnostic lines beginning with several asterisks from being mistaken for the root-document line.

Save the result as appropriate, for example:

ROOT_TEX=user_guide.tex

7. Compile an explicit root document

Once the root filename is known:

overleaf --experimental \
    --resource-path "$ROOT_TEX" \
    compile "$ID"

This is useful when a project contains multiple independently compilable TeX documents or when scripting a publication workflow.

8. Download the PDF

Compile and save the resulting PDF:

overleaf --experimental \
    --resource-path "$ROOT_TEX" \
    --output document.pdf \
    pdf "$ID"

Check it:

file document.pdf
ls -lh document.pdf

On a Linux desktop, open it with the system default viewer:

xdg-open document.pdf >/dev/null 2>&1 &

On Windows from MSYS2 or Git Bash:

start document.pdf

If Windows path conversion is needed explicitly:

cmd.exe /c start "" "$(cygpath -w document.pdf)"

9. Retrieve build artifacts

The compile result exposes useful LaTeX diagnostics. For example:

overleaf --experimental \
    --output document.log \
    output "$ID" output.log

overleaf --experimental \
    --output document.bbl \
    output "$ID" output.bbl

overleaf --experimental \
    --output document.chktex \
    output "$ID" output.chktex

Inspect them using ordinary shell tools:

tail -100 document.log
cat document.bbl
cat document.chktex

Only artifacts actually reported by compile can be downloaded with output.

10. Use the official Git bridge

The Git bridge does not use ~/.overleaf/session. It uses Overleaf's Git integration and token-based Git authentication, with credentials handled by Git.

Print the remote URL:

overleaf git-url "$ID"

Clone the Overleaf project:

overleaf clone "$ID" my-paper

Inspect the clone:

cd my-paper
git status
git remote -v
git log --oneline -10

Pull changes made in the Overleaf editor:

cd ..
overleaf pull my-paper

After editing locally, commit normally:

cd my-paper
git add .
git commit -m 'update paper'
cd ..

For a clone whose current branch already tracks the Overleaf remote:

overleaf push my-paper

The push command changes the remote Overleaf project, so verify git status and the commits you intend to publish before using it.

11. Add Overleaf to an existing Git repository

Instead of cloning, an existing local repository can gain an Overleaf remote:

cd existing-paper
overleaf remote-add . "$ID" overleaf
git remote -v

Overleaf's Git bridge has important differences from a general-purpose Git server and exposes one linear project history. Branch naming has varied in practice and documentation, so overleaf compile follows the branch actually tracked/advertised by the selected remote rather than assuming master or main.

For an existing repository, inspect the remote first:

git remote show overleaf

Then reconcile unrelated histories according to Overleaf's Git documentation before the first push. If automatic branch discovery is unavailable to the client, select the intended branch explicitly:

overleaf --remote-branch main --experimental compile main.tex

12. A compact repeatable workflow

After the initial setup, an ordinary read/compile/download cycle can be as small as:

ID=0123456789abcdef

overleaf --experimental --output project.zip zip "$ID"
overleaf --experimental compile "$ID"
overleaf --experimental --output output.log output "$ID" output.log
overleaf --experimental --output document.pdf pdf "$ID"

start document.pdf

Use xdg-open document.pdf instead of start on Linux.

ENVIRONMENT

OVERLEAF_SESSION

Browser-session cookie value used before the default ~/.overleaf/session file when no explicit session option is supplied.

OVERLEAF_GIT_TOKEN

Git authentication token used before the default ~/.overleaf/git-token file. When set, the CLI supplies the token to Git through GIT_ASKPASS with username git.

EXAMPLES

Create a protected browser-session file after copying the current overleaf_session2 value from browser Developer Tools:

read -rsp 'Paste overleaf_session2 value: ' OL_SESSION; printf '\n'
printf '%s\n' "$OL_SESSION" > ~/.overleaf/session
unset OL_SESSION
chmod 600 ~/.overleaf/session

List projects using that file:

overleaf --experimental --session-file ~/.overleaf/session projects

List projects using the environment instead:

OVERLEAF_SESSION='...' overleaf --experimental projects

Clone a paper through the official Git bridge:

overleaf clone 0123456789abcdef paper

Add an Overleaf remote to an existing local repository:

overleaf remote-add . 0123456789abcdef overleaf

Generate an Open in Overleaf URL:

overleaf open-uri \
    --engine lualatex \
    --main-document AUTHOR-paper.tex \
    https://example.org/paper.zip

Compile a specific root document:

OVERLEAF_SESSION='...' \
    overleaf --experimental \
    --resource-path AUTHOR-paper.tex \
    compile 0123456789abcdef

Compile and retrieve the resulting PDF:

OVERLEAF_SESSION='...' \
    overleaf --experimental \
    --resource-path AUTHOR-paper.tex \
    --output AUTHOR-paper.pdf \
    pdf 0123456789abcdef

Retrieve the compilation log:

OVERLEAF_SESSION='...' \
    overleaf --experimental \
    --output AUTHOR-paper.log \
    output 0123456789abcdef output.log

EXIT STATUS

0 indicates success.

1 indicates an operational error, including invalid API arguments, authentication failures, HTTP failures, Git failures, and file I/O failures.

2 indicates command-line usage failure, such as an unknown command.

SECURITY

OVERLEAF_SESSION is an authentication credential. Treat it like a password. Do not commit it, log it, include it in bug reports, or expose it in shell history.

The --session option is less private than OVERLEAF_SESSION or --session-file because command-line arguments may be visible in process listings.

When an Overleaf Git token is supplied through OVERLEAF_GIT_TOKEN, --git-token-file, or ~/.overleaf/git-token, the client passes it to Git through a temporary GIT_ASKPASS helper. The token is not added to Git URLs or process arguments. If no token is configured, ordinary Git credential handling and interactive prompting remain available.

IMPLEMENTATION

Command-line options are parsed with Getopt2h2o from Util::H2O::More. Commands are routed with Dispatch::Fu. The executable is a modulino whose package is local::bin::overleaf.

SCIENCE PERL JOURNAL WORKFLOW

overleaf is general-purpose tooling. It was developed in part from the same practical Git, LaTeX, and Overleaf work used while helping authors and editors prepare material for the Science Perl Journal. The author is a member of the Perl Community's Science Perl Committee and a Co-Editor of the Journal.

The tool is not a submission requirement, and authors are free to use whatever LaTeX workflow serves their work well. For Perl programmers who might enjoy sharing scientific, engineering, or other technical work, information about the Science Perl Committee is available at:

https://perlcommunity.org/science/

The Science Perl Journal is available online at:

https://science.perlcommunity.org/spj

Prospective authors may consult:

https://science.perlcommunity.org/spj/about/submissions

Readers interested in printed issues can find current availability through the Journal's announcements:

https://science.perlcommunity.org/spj/announcement

AUTHOR

Brett Estrade <oodler@cpan.org>

Member, Perl Community's Science Perl Committee.

Co-Editor, The Science Perl Journal.

LICENSE

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

To install Webservice::Overleaf::API, copy and paste the appropriate command in to your terminal.

cpanm

cpanm Webservice::Overleaf::API

CPAN shell

perl -MCPAN -e shell
install Webservice::Overleaf::API

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	Go to GitHub issues (only if GitHub is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

SYNOPSIS

DESCRIPTION

COMMANDS

project-url PROJECT_ID

git-url PROJECT_ID

open-uri URL [URL ...]

open-data FILE

snippet-form FILE

clone PROJECT_ID DIRECTORY

pull DIRECTORY

push DIRECTORY

remote-add DIRECTORY PROJECT_ID [REMOTE]

bootstrap

projects

zip PROJECT_ID

compile PROJECT_ID

compile [ROOT.tex]

pdf PROJECT_ID

output PROJECT_ID PATH

help

OPTIONS

-h, --help

-v, --version

--experimental

--session VALUE

--session-file FILE

--git-token-file FILE

--remote-branch NAME

--csrf VALUE

--base-url URL

--git-base-url URL

--cookie-name NAME

--timeout SECONDS

--engine ENGINE

--main-document FILE

--visual-editor, --no-visual-editor

--name NAME

--mime TYPE

-o FILE, --output FILE

--resource-path FILE

--remote NAME

--push, --no-push

AUTHENTICATION

Why two credentials?

Standard credential directory

Set up the browser session: ~/.overleaf/session

Set up the Git token: ~/.overleaf/git-token

Combined authenticated workflow

Troubleshooting the two authentication paths

Session lifetime

PRACTICAL WALKTHROUGH

1. Obtain the browser session

2. Verify the session

3. List projects and choose an ID

4. Download and inspect the source project

5. Compile the project

6. Discover the configured root TeX document

7. Compile an explicit root document

8. Download the PDF

9. Retrieve build artifacts

10. Use the official Git bridge

11. Add Overleaf to an existing Git repository

12. A compact repeatable workflow

ENVIRONMENT

OVERLEAF_SESSION

OVERLEAF_GIT_TOKEN

EXAMPLES

EXIT STATUS

SECURITY

IMPLEMENTATION

SCIENCE PERL JOURNAL WORKFLOW

AUTHOR

LICENSE

Module Install Instructions

Keyboard Shortcuts