pickfit

BrowseDeveloper CLIs

Posting

A terminal-based HTTP client for building and sending HTTP, GraphQL and gRPC requests, with requests stored locally as YAML files.

Tested on Linux

Use it

Linux x86_64

You need first

  • Runtimes: go>=1.25.5 (for go install)
  1. Download v3.0.0-beta.1 linux_amd64 release archive, verify checksum, install binary to ~/.local/bin

    mkdir -p /tmp/posting && cd /tmp/posting && curl -fsSLO https://github.com/darrenburns/posting/releases/download/v3.0.0-beta.1/posting_3.0.0-beta.1_linux_amd64.tar.gz && curl -fsSLO https://github.com/darrenburns/posting/releases/download/v3.0.0-beta.1/checksums.txt && sha256sum --ignore-missing -c checksums.txt && tar xzf posting_3.0.0-beta.1_linux_amd64.tar.gz && mkdir -p ~/.local/bin && install -m755 posting ~/.local/bin/posting

Check that it works

posting --help

The output should contain “A terminal HTTP client.”.

First thing to try

mkdir -p /tmp/srv /tmp/coll/http /tmp/coll/gql && cat > /tmp/srv/server.py <<'EOF'
import json
from http.server import BaseHTTPRequestHandler, HTTPServer
class H(BaseHTTPRequestHandler):
    def _send(self, obj):
        b = json.dumps(obj).encode()
        self.send_response(200); self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(b))); self.end_headers(); self.wfile.write(b)
    def do_GET(self):
        self._send({"path": self.path, "data": {"users": [{"id": 1, "role": "user"}, {"id": 42, "role": "admin"}]}})
    def do_POST(self):
        body = json.loads(self.rfile.read(int(self.headers.get("Content-Length", 0))) or b"{}")
        self._send({"data": {"user": {"name": "Ada", "id": body.get("variables", {}).get("id")}}, "echo_query": body.get("query")})
HTTPServer(("127.0.0.1", 8765), H).serve_forever()
EOF
cat > /tmp/coll/posting.env <<'EOF'
HOST=127.0.0.1
PORT=1
API_PATH=/api/v1
EOF
cat > /tmp/coll/dev.env <<'EOF'
PORT=8765
BASE_URL="http://${HOST}:${PORT}${API_PATH}"
EOF
cat > /tmp/coll/http/01-list.posting.yaml <<'EOF'
name: List users
method: GET
url: ${BASE_URL}/users
captures:
  ADMIN_ID: data.users[?(@.role == "admin")].id
EOF
cat > /tmp/coll/http/02-get.posting.yaml <<'EOF'
name: Get admin
method: GET
url: ${BASE_URL}/users/${ADMIN_ID}
EOF
cat > /tmp/coll/gql/01-user.posting.yaml <<'EOF'
name: Get user
kind: graphql
url: ${BASE_URL}/graphql
graphql:
  query: |
    query User($id: ID!) {
      user(id: $id) { name }
    }
  variables: |
    {"id": "7"}
  operation_name: User
EOF
python3 /tmp/srv/server.py
posting run -c /tmp/coll http --env dev --json

Run posting in a terminal to open the request editor.

What it does

  • Send HTTP, GraphQL and gRPC requests
    How to use it
    1. Save each request as a .posting.yaml file in a folder inside your collection directory, and put variables in .env files there.
    2. Run posting run -c <collection> <folder> --env <env> --json to send every request in that folder.
    3. Check the JSON output for each request's URL and the count of passed requests.
    Tested
  • Work on several requests in tabs
    Not tested
  • Explore responses with a JSON tree and JSONPath
    Not shown working
  • Manage layered environments and variables
    Not shown working

How far pickfit got

Linux x86_64

  1. Installs
  2. Starts
  3. 1 of 4 features work
  4. Works offline

macOS and Windows: the project says it runs there; pickfit hasn’t tried it.

Good for

  • send and test HTTP API requests from the terminal over SSH
  • import curl commands and export requests as curl
  • import API collections from OpenAPI, Postman and Bruno
  • filter JSON responses with JSONPath

An alternative to Postman and Insomnia.

How pickfit tested it

Each run starts from a clean machine and follows the steps above. How pickfit verifies

Linux x86_64

Its main function works

  • Replayed from scratch
  • Works offline
  • Checked on 15 Nov 2026
  • Version 3.0.0-beta.1

Differences the test machine hit

  • README: Install with Homebrew or `go install` (Go 1.25.5+)
    In the test: The Linux release archive posting_3.0.0-beta.1_linux_amd64.tar.gz from GitHub releases contains a standalone binary; no Go toolchain needed
  • README: Only usage example is `posting` (full-screen TUI)
    In the test: Headless testing uses `posting run -c DIR PATH --env NAME --json`, documented in --help and docs/guide/running.md, not in the README

How to read a tool card

Stitching
pickfit installed this tool itself. Everything under the stitches comes from that run. A tool pickfit has not run never gets stitches.
Verified on your OS
The install steps ran on the system you chose. “Ran on Linux only” means it has not been run on yours yet.
macOS, Linux and WindowsWhere it ran
Green OS marks: pickfit ran the install steps there. Grey ones: the README says it runs there, and pickfit has not tried.
How far the run got
Installs and starts, its main function works, its service answers, it produces model output. A window means a desktop app opened; a plug, an MCP client used it. The mark sits beside the run’s result, under “Why it fits and how we know” and in “How pickfit tested it”.
Visual check
pickfit looked at screenshots of the app. Green: it looks right. Amber with a number: things that look wrong; open it to see them. Grey and dashed: not checked yet.
Known vulnerabilities
Known high or critical vulnerabilities (OSV.dev) in what it installs. Green: none known. Red with a number: how many; open it for the list, and read it before you install. Grey and dashed: not checked, which does not mean safe.
About the run
The day it ran, and the version that ran.
Source of a reason
Every reason a pick fits rests on one profile field. Open the reason to see the field and the value it relies on.
Hidden gem
High quality, little known.
Quality and popularity
Two scores out of 100. Quality: how well it installed and worked when pickfit tried it, and how good its install docs and upkeep are. Popularity: from stars, downloads and Hacker News.
Features checked
Of the main features the README advertises, how many the run actually exercised (green), and how many failed (red). Grey ones were not checked, and the card says why.
Not verified
A well-known tool Fitz mentions from general knowledge. No run record, no steps, no score.