apieri

An opinionated, Vim-friendly HTTP notebook for the terminal.

Built for exploration, not for automation.

⚠️ 100% vibecoded by hand.

Written in Rust, which legally requires us to describe it as blazingly fast.

I built Apieri for myself: paste a curl command, make it readable, run it, and keep the useful requests — without leaving the terminal.

It is keyboard-first by design, with familiar Vim modes and motions at the center of the workflow rather than layered on as an afterthought.

It is intentionally lightweight. There is no account to create, no cloud workspace to organize, and no project setup between you and the first request.

• Curl-first. Paste the commands you already have, or use a small readable HTTP DSL when writing a request from scratch.
• Easy to take elsewhere. Export requests and responses to Markdown or Textile, or open a response in your preferred editor for further analysis.
• Keyboard-first. Navigate, edit, execute, and manage notebook cells without reaching for the mouse.
• Readable responses. See status, timing, response size, syntax-highlighted JSON, headers, and search results in one focused view.
• A notebook, not a collection form. Mix request cells with Markdown notes to annotate your workflow and keep the context of your exploration.
• History that follows you. Executed requests go into a persistent local history and can be restored as new cells without running them again.

1. Open apieri and get an empty scratch notebook.
2. Paste a curl command. Apieri formats the command, query parameters, and JSON body automatically.
3. Edit and run it with familiar Vim-style controls.
4. Inspect the response body or headers, then search without leaving the TUI.
5. Pull a useful request back from local history or save the notebook for later.

The common path stays short: open → paste → run → inspect.

Install directly from the repository:

cargo install --git https://github.com/lex009/apieri

Once a tagged GitHub release is published, you can use its prebuilt installer on macOS or Linux:

curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/lex009/apieri/releases/latest/download/apieri-installer.sh | sh

Or use PowerShell on Windows:

powershell -ExecutionPolicy ByPass -c "irm https://github.com/lex009/apieri/releases/latest/download/apieri-installer.ps1 | iex"

Then start Apieri:

apieri

To build and run it directly from source instead:

git clone https://github.com/lex009/apieri.git
cd apieri
cargo run --release

Inside Apieri:

1. Press o to create a request cell.
2. Paste a curl command.
3. Press Esc to return to Normal mode.
4. Press Enter to execute.

That is enough for the first request. Press ? whenever you want the full in-app help.

Use --debug to write local diagnostics without mixing log output into the TUI's alternate screen:

apieri --debug

Apieri prints the selected log path before opening the TUI. By default, each run creates a timestamped session log under the platform cache directory in apieri/logs/ and keeps the latest 10 sessions. To choose the file yourself, use --debug-log; this also enables debug logging and the file is not removed by automatic cleanup:

apieri --debug-log ./apieri-debug.log

The default filter is apieri=debug. Use RUST_LOG for more detail, including per-event input routing:

RUST_LOG=apieri=trace apieri --debug

Diagnostics include application and terminal lifecycle, commands, storage, execution queue, and sanitized HTTP metadata. They never include request or response URLs, query strings, headers, bodies, editor or paste contents, history queries, environment values, or complete external-editor commands. Panics and backtraces are written to the same session log.

Start with a curl command copied from documentation, DevTools, or a teammate:

curl -X POST https://api.example.com/users \
  -H 'Content-Type: application/json' \
  -d '{"name":"Ada","role":"engineer"}'

Or express the same request with Apieri's compact HTTP format:

POST https://api.example.com/users
Content-Type: application/json

{
  "name": "Ada",
  "role": "engineer"
}

Long curl commands, query strings, and valid JSON bodies are formatted for readability while the request keeps its original meaning.

Formatted curl keeps the URL on the first line. Collapsed request cells show the HTTP method and base URL, so requests remain easy to identify without expanding or executing them.

Apieri follows Vim conventions where they make the workflow faster, including Normal, Insert, Visual, and Command modes.

Notebooks and request history stay on your machine. Apieri does not require an account and does not upload your workspace to a hosted service.

Global history stores requests only — never responses, status codes, errors, or response timings. A stored request includes its source text, URL, method, headers, and body. That means authorization headers and other secrets are also written to the local history database when they are part of a request. Treat that database as sensitive data.

Apieri is not trying to cover every API workflow. I add things when they make my daily loop faster and try to keep everything else out of the way. The guiding question is simple: does this help me go from a request to a useful answer with less friction?