Skip to content
Back to search

pinchtab

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/pinchtab-pinchtab/badge.svg)](/listings/pinchtab-pinchtab)

HTML

<a href="/listings/pinchtab-pinchtab"><img src="/api/listings/pinchtab-pinchtab/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Installation

**macOS / Linux:**

curl -fsSL https://pinchtab.com/install.sh | bash

**Homebrew (macOS / Linux):**

brew install pinchtab/tap/pinchtab

**npm:**

npm install -g pinchtab

Agent skill

The npm package ships the `pinchtab` agent skill and copies it into every agent home it detects (`~/.claude/skills`, `~/.cursor/skills`, `~/.windsurf/skills`, `~/.codex/skills`, OpenClaw) on install and upgrade, printing what it wrote. The shipped copy carries the release version and a content hash in its frontmatter, so a stale or hand-edited copy is detectable without a source checkout:

pinchtab skill status           # each detected copy vs the bundled skill; exit 1 if any is stale
pinchtab skill update           # install or refresh; an edited copy is kept and reported
pinchtab skill update --force   # replace an edited copy

Inside a checkout, `scripts/install-skills.sh` symlinks the repo skills instead so edits are live; the sync never writes through a symlink.

Platform Support

PinchTab's primary tested operator workflow is local macOS and Linux.

Windows binaries are published, but Windows support is currently limited and best-effort because the project does not have the same level of automated and manual coverage there. On Windows, prefer running `pinchtab server` or `pinchtab bridge` directly instead of relying on the daemon workflow.

On **macOS**, prefer a dedicated automation browser (Google Chrome for Testing or Chromium) over your daily Google Chrome. Driving your primary Chrome headless can prevent it from opening a normal window while PinchTab is running. PinchTab now prefers a dedicated browser automatically, and `pinchtab doctor browsers` warns if automation would fall back to your primary Chrome — install Chrome for Testing or set `browser.binary` to a separate build. See [docs/reference/config.md](docs/reference/config.md).

Shell Completion

Generate and install shell completions after `pinchtab` is on your `PATH`:

# Generate and install zsh completions
pinchtab completion zsh > "${fpath[1]}/_pinchtab"

# Generate bash completions
pinchtab completion bash > /etc/bash_completion.d/pinchtab

# Generate fish completions
pinchtab completion fish > ~/.config/fish/completions/pinchtab.fish

**Docker:**

docker run -d \
  --name pinchtab \
  -p 127.0.0.1:9867:9867 \
  -v pinchtab-data:/data \
  --shm-size=2g \
  pinchtab/pinchtab

The bundled container persists its managed config at `/data/.config/pinchtab/config.json`. If you want to supply your own config file instead, mount it and point `PINCHTAB_CONFIG` at it:

docker run -d \
  --name pinchtab \
  -p 127.0.0.1:9867:9867 \
  -e PINCHTAB_CONFIG=/config/config.json \
  -v "$PWD/config.json:/config/config.json:ro" \
  -v pinchtab-data:/data \
  --shm-size=2g \
  pinchtab/pinchtab

Use It

**First useful command — auto-starts the local server if needed:**

pinchtab nav https://pinchtab.com --snap

**Or start the server explicitly when you want foreground logs:**

pinchtab server

**Recommended for daily local use — install the daemon once:**

pinchtab daemon install
pinchtab daemon

That keeps PinchTab running in the background so your agent tools can reuse it without an open terminal.

**Terminal 2 — Control the browser:**

# Navigate; starts the server automatically if needed
pinchtab nav https://pinchtab.com

# Get page structure
pinchtab snap -i -c

# Click an element
pinchtab click e5

# Extract text
pinchtab text

Or use the HTTP API directly (every request needs the server token):

export PINCHTAB_TOKEN=$(pinchtab config token --stdout)

# Create a profile first (returns profile id)
PROF=$(curl -s -X POST http://localhost:9867/profiles \
  -H "Authorization: Bearer $PINCHTAB_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"work"}' | jq -r '.id')

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 475 lines · 2 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="assets/pinchtab-headless.png" alt="PinchTab" width="200"/>
  3. </p>
  4. <p align="center">
  5. <strong>PinchTab</strong><br/>
  6. <strong>Browser control for AI agents</strong><br/>
  7. Small Go binary • HTTP API • Token-efficient
  8. </p>
  9. <table align="center">
  10. <tr>
  11. <td align="center" valign="middle">
  12. <a href="https://pinchtab.com/docs"><img src="assets/docs-no-background-256.png" alt="Full Documentation" width="92"/></a>
  13. </td>
  14. <td align="left" valign="middle">
  15. <a href="https://github.com/pinchtab/pinchtab/releases/latest"><img src="https://img.shields.io/github/v/release/pinchtab/pinchtab?style=flat-square&color=FFD700" alt="Release"/></a><br/>
  16. <a href="https://github.com/pinchtab/pinchtab/actions/workflows/ci-go.yml"><img src="https://img.shields.io/github/actions/workflow/status/pinchtab/pinchtab/ci-go.yml?branch=main&style=flat-square&label=Go%20CI" alt="Go CI"/></a><br/>
  17. <img src="https://img.shields.io/badge/Go-1.26+-00ADD8?style=flat-square&logo=go&logoColor=white" alt="Go 1.26+"/><br/>
  18. <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue?style=flat-square" alt="License"/></a>
  19. </td>
  20. </tr>
  21. </table>
  22. ---
  23. ## What is PinchTab?
  24. PinchTab is a **standalone HTTP server** that gives AI agents direct control over Chrome.
  25. For day-to-day local use, the server is typically installed as a user-level daemon, allowing agent tools to reuse the same browser control plane running in the background.
  26. ```bash
  27. curl -fsSL https://pinchtab.com/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 35 on GitHub
  28. # or
  29. pinchtab daemon install
  30. ```
  31. This installs the control-plane server and starts a default headless Chrome instance, ready to accept requests from agents or manual API calls.
  32. PinchTab is designed first for local, single-user control on a machine you manage. Remote and distributed layouts are supported, but they are advanced operator-managed deployments. If you bind beyond loopback, publish ports, or attach remote bridges, you are responsible for tokens, network boundaries, TLS or reverse proxying, and which endpoint families you expose.
  33. If you run PinchTab on a different machine, do it only when you understand the security model. Keep it on a private or otherwise closed network, avoid exposing it directly to the public internet, and keep high-risk endpoint families disabled unless you explicitly need them. If you do enable them, lock them down so only the systems that need them can reach them.
  34. > [!WARNING]
  35. > The dashboard, HTTP API, MCP server, and remote CLI integrations are privileged operator control surfaces. They are not designed for untrusted users, multi-tenant exposure, or direct public-internet access. If you are unsure how to secure a non-local deployment, review [docs/guides/security.md](docs/guides/security.md) and use the private security contact path in [SECURITY.md](SECURITY.md) before exposing the service.
  36. If you prefer not to run a daemon, or if you're on Windows, you can instead run:
  37. `pinchtab server` — runs the control-plane server directly
  38. `pinchtab bridge` — runs a single browser instance as a lightweight runtime
  39. Running bare `pinchtab` runs the security setup on first use, then prints server status, the security posture, and suggested next steps:
  40. `pinchtab`
  41. ## Security
  42. PinchTab defaults to a **local-first security posture**:
  43. - `server.bind = 127.0.0.1`
  44. - dashboard session cookies are `Secure` only when the dashboard is actually served over HTTPS
  45. - sensitive endpoint families are disabled by default
  46. - `attach` is disabled by default
  47. - IDPI is enabled with a **local-only website allowlist**
  48. If you intentionally access the dashboard over plain HTTP on a non-loopback
  49. address, PinchTab now warns in the UI that the session is running without
  50. transport encryption. Prefer HTTPS or localhost when possible. If you force
  51. `server.cookieSecure = true`, dashboard login requires HTTPS and will fail
  52. explicitly on plain HTTP instead of looping silently.
  53. > [!CAUTION]
  54. > By default, IDPI restricts browsing to **locally hosted websites only**.
  55. > This prevents agents from navigating the public internet until you explicitly allow it.
  56. > The restriction exists to make the security implications of browser automation clear before enabling wider access.
  57. >
  58. > Expanding browsing to non-local or non-trusted websites is a security-reducing choice. Hostile pages can still increase browser attack surface and interact badly with enabled automation features even when PinchTab's content defenses are on.
  59. See the full guide: [docs/guides/security.md](docs/guides/security.md)
  60. Remote, container, and distributed setups are possible, but PinchTab is not positioned as a turnkey internet-facing browser service. Treat any non-local deployment as an advanced setup that you must secure explicitly.
  61. ## What can you use it for
  62. ### Headless navigation
  63. With the daemon installed and an agent skill configured, an agent can execute tasks like:
  64. ```
  65. "What are the main news about aliens on news.com?"
  66. ```
  67. PinchTab exposes browser tools that allow agents to navigate pages, extract structured content, and interact with the DOM without wasting tokens on raw HTML or images.
  68. ### Headed navigation
  69. In addition to headless automation, PinchTab supports headed Chrome profiles.
  70. You can create profiles configured with authentication, cookies, extensions, or specific environments. Each profile can have a name and description.
  71. For example, an agent request like:
  72. ```
  73. "Log into my work profile and download the weekly report"
  74. ```
  75. can automatically select the appropriate profile and perform the action.
  76. ### Site audits and visual comparison
  77. PinchTab can audit whole sites at the browser level — screenshots, console
  78. errors, broken assets, accessibility score, Core Web Vitals, and security
  79. findings — and compare two site versions visually before a release:
  80. ```bash
  81. pinchtab audit https://example.com --output-dir ./audit # report.json + screenshots/
  82. pinchtab audit https://example.com/sitemap.xml --sitemap --sample-size 2 --output-dir ./audit
  83. pinchtab compare https://example.com https://staging.example.com --fail-on-diff # CI gate
  84. ```
  85. See [docs/audit.md](docs/audit.md) for the full command reference, report
  86. anatomy, and CI examples.
  87. ### Local container isolation
  88. If you prefer stronger isolation, PinchTab can run inside Docker.
  89. This allows agents to control browsers in a sandboxed environment, reducing risk when running automation tasks locally.
  90. ### Distributed automation
  91. PinchTab can manage multiple Chrome instances (headless or headed) across containers or remote machines.
  92. Typical use cases include:
  93. - QA automation
  94. - testing environments
  95. - distributed browsing tasks
  96. - development tooling
  97. You can connect to multiple PinchTab servers, or attach to Chrome instances running in remote debug mode.
  98. ## Process Model
  99. PinchTab is server-first:
  100. 1. install the daemon or run `pinchtab server` for the full control plane
  101. 2. let the server manage profiles and instances
  102. 3. let each managed instance run behind a lightweight `pinchtab bridge` runtime
  103. In practice:
  104. - Server — the main product entry point and control plane
  105. - Bridge — the runtime that manages a single browser instance
  106. - Attach — an advanced mode for registering externally managed Chrome instances
  107. ### Primary Usage
  108. The primary user journey is:
  109. 1. install Pinchtab
  110. 2. install and start the daemon with `pinchtab daemon install`
  111. 3. point your agent or tool at `http://localhost:9867`
  112. 4. let PinchTab act as your local browser service
  113. That is the default “replace the browser runtime” scenario.
  114. Most users should not need to think about `pinchtab bridge` directly, and only need bare `pinchtab` for first-run setup or a status overview.
  115. Agent plugins (binary still installed separately):
  116. ```bash
  117. # Grok Build, after listing in the official xAI marketplace
  118. grok plugin install pinchtab --trust
  119. # OpenClaw
  120. openclaw plugins install @pinchtab/pinchtab
  121. ```
  122. Grok users can install from the PinchTab repository marketplace or directly from GitHub. See the [Grok plugin install and usage guide](plugins/grok/README.md).
  123. ### Key Features
  124. - **CLI or Curl** — Control via command-line or HTTP API
  125. - **Token-efficient** — 800 tokens/page with text extraction (5-13x cheaper than screenshots)
  126. - **Headless or Headed** — Run without a window or with visible Chrome
  127. - **Multi-instance** — Run multiple parallel Chrome processes with isolated profiles
  128. - **Self-contained** — single ~30MB binary; drives a locally installed Chrome or Chromium
  129. - **Accessibility-first** — Element refs that denote a DOM node, not a row: the same `e5` survives a change of filter, selector or depth (filtered views are sparse), and expires only on navigation to a new document
  130. - **ARM64-optimized** — First-class Raspberry Pi support with automatic Chromium detection
  131. - **CloakBrowser support** — Optional drop-in provider for sites that fingerprint stock Chromium. PinchTab launches a user-supplied CloakBrowser binary; no CloakBrowser is bundled in released artifacts. See [docs/guides/cloakbrowser.md](docs/guides/cloakbrowser.md).
  132. ---
  133. ## Quick Start
  134. ### Installation
  135. **macOS / Linux:**
  136. ```bash
  137. curl -fsSL https://pinchtab.com/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 201 on GitHub
  138. ```
  139. **Homebrew (macOS / Linux):**
  140. ```bash
  141. brew install pinchtab/tap/pinchtab
  142. ```
  143. **npm:**
  144. ```bash
  145. npm install -g pinchtab
  146. ```
  147. ### Agent skill
  148. The npm package ships the `pinchtab` agent skill and copies it into every agent home it detects (`~/.claude/skills`, `~/.cursor/skills`, `~/.windsurf/skills`, `~/.codex/skills`, OpenClaw) on install and upgrade, printing what it wrote. The shipped copy carries the release version and a content hash in its frontmatter, so a stale or hand-edited copy is detectable without a source checkout:
  149. ```bash
  150. pinchtab skill status # each detected copy vs the bundled skill; exit 1 if any is stale
  151. pinchtab skill update # install or refresh; an edited copy is kept and reported
  152. pinchtab skill update --force # replace an edited copy
  153. ```
  154. Inside a checkout, `scripts/install-skills.sh` symlinks the repo skills instead so edits are live; the sync never writes through a symlink.
  155. ### Platform Support
  156. PinchTab's primary tested operator workflow is local macOS and Linux.
  157. Windows binaries are published, but Windows support is currently limited and best-effort because the project does not have the same level of automated and manual coverage there. On Windows, prefer running `pinchtab server` or `pinchtab bridge` directly instead of relying on the daemon workflow.
  158. On **macOS**, prefer a dedicated automation browser (Google Chrome for Testing or Chromium) over your daily Google Chrome. Driving your primary Chrome headless can prevent it from opening a normal window while PinchTab is running. PinchTab now prefers a dedicated browser automatically, and `pinchtab doctor browsers` warns if automation would fall back to your primary Chrome — install Chrome for Testing or set `browser.binary` to a separate build. See [docs/reference/config.md](docs/reference/config.md).
  159. ### Shell Completion
  160. Generate and install shell completions after `pinchtab` is on your `PATH`:
  161. ```bash
  162. # Generate and install zsh completions
  163. pinchtab completion zsh > "${fpath[1]}/_pinchtab"
  164. # Generate bash completions
  165. pinchtab completion bash > /etc/bash_completion.d/pinchtab
  166. # Generate fish completions
  167. pinchtab completion fish > ~/.config/fish/completions/pinchtab.fish
  168. ```
  169. **Docker:**
  170. ```bash
  171. docker run -d \
  172. --name pinchtab \
  173. -p 127.0.0.1:9867:9867 \
  174. -v pinchtab-data:/data \
  175. --shm-size=2g \
  176. pinchtab/pinchtab
  177. ```
  178. The bundled container persists its managed config at `/data/.config/pinchtab/config.json`.
  179. If you want to supply your own config file instead, mount it and point `PINCHTAB_CONFIG` at it:
  180. ```bash
  181. docker run -d \
  182. --name pinchtab \
  183. -p 127.0.0.1:9867:9867 \
  184. -e PINCHTAB_CONFIG=/config/config.json \
  185. -v "$PWD/config.json:/config/config.json:ro" \
  186. -v pinchtab-data:/data \
  187. --shm-size=2g \
  188. pinchtab/pinchtab
  189. ```
  190. ### Use It
  191. **First useful command — auto-starts the local server if needed:**
  192. ```bash
  193. pinchtab nav https://pinchtab.com --snap
  194. ```
  195. **Or start the server explicitly when you want foreground logs:**
  196. ```bash
  197. pinchtab server
  198. ```
  199. **Recommended for daily local use — install the daemon once:**
  200. ```bash
  201. pinchtab daemon install
  202. pinchtab daemon
  203. ```
  204. That keeps PinchTab running in the background so your agent tools can reuse it without an open terminal.
  205. **Terminal 2 — Control the browser:**
  206. ```bash
  207. # Navigate; starts the server automatically if needed
  208. pinchtab nav https://pinchtab.com
  209. # Get page structure
  210. pinchtab snap -i -c
  211. # Click an element
  212. pinchtab click e5
  213. # Extract text
  214. pinchtab text
  215. ```
  216. Or use the HTTP API directly (every request needs the server token):
  217. ```bash
  218. export PINCHTAB_TOKEN=$(pinchtab config token --stdout)
  219. # Create a profile first (returns profile id)
  220. PROF=$(curl -s -X POST http://localhost:9867/profiles \
  221. -H "Authorization: Bearer $PINCHTAB_TOKEN" \
  222. -H "Content-Type: application/json" \
  223. -d '{"name":"work"}' | jq -r '.id')
  224. # Start an instance for that profile (returns instance id)
  225. INST=$(curl -s -X POST http://localhost:9867/instances/start \
  226. -H "Authorization: Bearer $PINCHTAB_TOKEN" \
  227. -H "Content-Type: application/json" \
  228. -d "{\"profileId\":\"$PROF\",\"mode\":\"headless\"}" | jq -r '.id')
  229. # Open a tab in that instance
  230. TAB=$(curl -s -X POST http://localhost:9867/instances/$INST/tabs/open \
  231. -H "Authorization: Bearer $PINCHTAB_TOKEN" \
  232. -H "Content-Type: application/json" \
  233. -d '{"url":"https://pinchtab.com"}' | jq -r '.tabId')
  234. # Get snapshot
  235. curl -H "Authorization: Bearer $PINCHTAB_TOKEN" "http://localhost:9867/tabs/$TAB/snapshot?filter=interactive"
  236. # Click element
  237. curl -X POST "http://localhost:9867/tabs/$TAB/action" \
  238. -H "Authorization: Bearer $PINCHTAB_TOKEN" \
  239. -H "Content-Type: application/json" \
  240. -d '{"kind":"click","ref":"e5"}'
  241. ```
  242. ---
  243. ## Core Concepts
  244. **Server** — The main PinchTab process. It manages profiles, instances, routing, and the dashboard.
  245. **Instance** — A running Chrome process. Each instance can have one profile.
  246. **Profile** — Browser state (cookies, history, local storage). Log in once, stay logged in across restarts.
  247. **Tab** — A single webpage. Each instance can have multiple tabs.
  248. **Bridge** — The single-instance runtime behind a managed instance. Usually spawned by the server, not started manually.
  249. Read more in the [Core Concepts](https://pinchtab.com/docs/core-concepts) guide.
  250. ---
  251. ## Why PinchTab?
  252. | Aspect | PinchTab |
  253. |--------|----------|
  254. | **Tokens performance** | ✅ |
  255. | **Headless and Headed** | ✅ |
  256. | **Profile** | ✅ |
  257. | **Advanced CDP control** | ✅ |
  258. | **Persistent sessions** | ✅ |
  259. | **Binary size** | ✅ |
  260. | **Multi-instance** | ✅ |
  261. | **External Chrome attach** | ✅ |
  262. ### Benchmark: PinchTab vs agent-browser
  263. Measured end-to-end agent-loop token cost (Anthropic API), percentages
  264. read as "PinchTab is N% cheaper than agent-browser on this metric":
  265. | Scope | Cost cheaper | Fewer requests | Fewer tokens |
  266. |---------------------------|-------------:|---------------:|-------------:|
  267. | Basic Haiku (10 steps) | **9.5%** | 23.0% | 17.9% |
  268. | Extended Haiku (24 steps) | **19.6%** | 31.1% | 26.2% |
  269. | Extended Sonnet (24 steps)| **20.3%** | 29.4% | 25.3% |
  270. The cost gap widens with workload length (click→snapshot round trips
  271. compound) and is roughly model-invariant at extended scope.
  272. See the [benchmark summary](./docs/benchmark.md) for an overview, or the
  273. [benchmark deep dive](./docs/deep-dive/benchmark.md) for full
  274. methodology, per-run tables, and raw logs.
  275. ---
  276. ## Privacy
  277. PinchTab is a fully open-source, local-first tool. No telemetry, no analytics, and no required outbound service dependency. The binary binds to `127.0.0.1` by default. Persistent profiles store browser sessions locally on your machine, similar to how a human reuses their browser. Remote and distributed deployments are available for advanced use cases, but they are explicit operator-managed setups rather than the default posture. The single Go binary (~30 MB) is fully verifiable: build from source at [github.com/pinchtab/pinchtab](https://github.com/pinchtab/pinchtab).
  278. ---
  279. ## Documentation
  280. Full docs at **[pinchtab.com/docs](https://pinchtab.com/docs)**
  281. ## Examples
  282. ### AI Agent Automation
  283. ```bash
  284. # Your AI agent can:
  285. pinchtab nav https://pinchtab.com
  286. pinchtab snap -i # Get clickable elements
  287. pinchtab click e5 # Click by ref
  288. pinchtab fill e3 "user@pinchtab.com" # Fill input
  289. pinchtab press e7 Enter # Submit form
  290. ```
  291. ### Data Extraction
  292. ```bash
  293. # Extract text (token-efficient)
  294. pinchtab nav https://pinchtab.com/article
  295. pinchtab text # ~800 tokens instead of 10,000
  296. ```
  297. ### Multi-Instance Workflows
  298. ```bash
  299. # Run multiple instances in parallel (profiles "alice" and "bob" must already exist — see POST /profiles above)
  300. curl -s -X POST http://localhost:9867/instances/start \
  301. -H "Authorization: Bearer $PINCHTAB_TOKEN" \
  302. -H "Content-Type: application/json" \
  303. -d '{"profileId":"alice","mode":"headless"}'
  304. curl -s -X POST http://localhost:9867/instances/start \
  305. -H "Authorization: Bearer $PINCHTAB_TOKEN" \
  306. -H "Content-Type: application/json" \
  307. -d '{"profileId":"bob","mode":"headless"}'
  308. # Each instance is isolated
  309. curl -H "Authorization: Bearer $PINCHTAB_TOKEN" http://localhost:9867/instances
  310. ```
  311. See [chrome-files.md](docs/implementations/chrome-files.md) for technical details on how PinchTab manages Chrome user data directories and ensures isolation between parallel instances.
  312. ---
  313. ## Development
  314. Want to contribute? Start with [CONTRIBUTING.md](CONTRIBUTING.md).
  315. The full setup and workflow guide lives at [docs/guides/contributing.md](docs/guides/contributing.md).
  316. **Quick start:**
  317. ```bash
  318. git clone https://github.com/pinchtab/pinchtab.git
  319. cd pinchtab
  320. ./dev doctor # Verifies environment, offers hooks/deps setup
  321. ./dev --help # Shows the developer toolkit commands
  322. go build ./cmd/pinchtab # Build pinchtab binary
  323. ```
  324. For diagnostics of your installed PinchTab + browser config (config file loads, browser found and version adequate, a headless launch exposes CDP, request shapes handled; CloakBrowser adds fingerprint-flag and font checks), use:
  325. ```bash
  326. pinchtab doctor # human-readable report
  327. pinchtab doctor --json # machine-readable
  328. pinchtab doctor --check <name> # run a single check by name
  329. pinchtab doctor browser <name> # scope to one browser.targets entry
  330. ```
  331. ---
  332. ## License
  333. MIT — Free and open source.
  334. ---
  335. **Get started:** [pinchtab.com/docs](https://pinchtab.com/docs)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.