Skip to content
Back to search

latchkey

A command-line tool that injects credentials to curl requests to known public APIs.

Safety scan

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

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/imbue-ai/latchkey with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/imbue-ai/latchkey'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/imbue-ai--latchkey/badge.svg)](/listings/imbue-ai--latchkey)

HTML

<a href="/listings/imbue-ai--latchkey"><img src="/api/listings/imbue-ai--latchkey/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.

Prerequisites

- `curl`, `node` and `npm` need to be present on your system in reasonably recent versions. - The `latchkey auth browser` subcommand requires a graphical environment.

Steps

npm install -g latchkey

# Optionally, if you intend to use `latchkey auth browser`:
latchkey ensure-browser

The `ensure-browser` command discovers and configures a browser for Latchkey to use. It searches for Chrome, Chromium, or Edge on your system. If none is found, it downloads Chromium via Playwright.

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 · 562 lines

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

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Latchkey
  2. [![npm](https://img.shields.io/npm/v/latchkey?style=flat-square)](https://npmjs.com/package/latchkey)
  3. [![CI](https://img.shields.io/github/actions/workflow/status/imbue-ai/latchkey/test.yml?style=flat-square)](https://github.com/imbue-ai/latchkey/actions)
  4. [![license](https://img.shields.io/npm/l/latchkey?style=flat-square)](LICENSE)
  5. [![downloads](https://img.shields.io/npm/dm/latchkey?style=flat-square)](https://npmjs.com/package/latchkey)
  6. Inject API credentials into agent requests.
  7. ## Quick example
  8. ```bash
  9. # User stores the credentials.
  10. latchkey auth set slack -H "Authorization: Bearer xoxb-your-token"
  11. # Agent makes http calls.
  12. latchkey curl -X POST 'https://slack.com/api/conversations.create' \
  13. -H 'Content-Type: application/json' \
  14. -d '{"name":"something-urgent"}'
  15. ```
  16. ## Overview
  17. Latchkey is a command-line tool that injects credentials into
  18. curl commands. Its [gateway mode](#gateway-mode) and [permission
  19. system](#permissions) can be used to keep tight control over
  20. sandboxed agents' usage of third-party services.
  21. - `latchkey services list`
  22. - List third-party services (Slack, Google Workspace, Linear, GitHub, etc.) that are supported out-of-the-box.
  23. - (In simple cases, `latchkey services register` can be used to add basic support for a new service at runtime.)
  24. - `latchkey curl <arguments>`
  25. - Automatically inject credentials into your otherwise standard curl calls to HTTP APIs.
  26. - Credentials must already exist (see below).
  27. - `latchkey auth set <service_name> <curl_arguments>`
  28. - Manually store credentials for a service as arbitrary curl arguments.
  29. - `latchkey auth browser <service_name>`
  30. - Open a browser login pop-up window and store the resulting API credentials.
  31. - This also allows agents to prompt users for credentials.
  32. - Only some services support this option.
  33. Latchkey is primarily designed for AI agents. By invoking
  34. Latchkey, agents can utilize user-provided credentials or prompt
  35. the user to authenticate, then continue interacting with HTTP
  36. APIs using standard curl syntax. No custom integrations or
  37. embedded credentials are required.
  38. Unlike OAuth-based flows or typical MCP-style integrations,
  39. Latchkey does not introduce an intermediary between the agent
  40. and the service. When the `browser` command is used, requests are made
  41. directly on the user’s behalf, which enables greater flexibility
  42. at the cost of formal delegation: agents authenticate as the
  43. user.
  44. Latchkey integrates with [Detent](https://github.com/imbue-ai/detent)
  45. to let you define fine-grained HTTP permissions for agents.
  46. If a service you need isn’t supported out of the box, the
  47. [new service registering mechanism](#entirely-new-services)
  48. may help. Otherwise, contributions are welcome! See the [development docs](docs/development.md)
  49. for details.
  50. You can also [leave us a note](https://github.com/imbue-ai/latchkey/issues/56).
  51. ## Installation
  52. ### Prerequisites
  53. - `curl`, `node` and `npm` need to be present on your system in reasonably recent versions.
  54. - The `latchkey auth browser` subcommand requires a graphical environment.
  55. ### Steps
  56. ```bash
  57. npm install -g latchkey
  58. # Optionally, if you intend to use `latchkey auth browser`:
  59. latchkey ensure-browser
  60. ```
  61. The `ensure-browser` command discovers and configures a browser
  62. for Latchkey to use. It searches for Chrome, Chromium, or Edge
  63. on your system. If none is found, it downloads Chromium via
  64. Playwright.
  65. ## Agent integrations
  66. Warning: giving AI agents access to your API credentials is
  67. potentially dangerous, especially when using the `auth browser`
  68. feature. They will be able to perform most of the actions you
  69. can. Only do this if you're willing to accept the risks.
  70. ### Using skills.sh
  71. ```bash
  72. npx skills add imbue-ai/latchkey
  73. ```
  74. ### From ClawHub
  75. ```bash
  76. npx clawhub install latchkey
  77. ```
  78. ### As a Pi package
  79. ```bash
  80. pi install npm:latchkey
  81. ```
  82. ### Manually
  83. The exact steps will differ depending on the agent. Taking OpenCode as an example:
  84. ```bash
  85. mkdir -p ~/.opencode/skills/latchkey
  86. latchkey skill-md > ~/.opencode/skills/latchkey/SKILL.md
  87. ```
  88. ### Using the Python `llm` tool
  89. See [integrations/llm-latchkey/README.md](integrations/llm-latchkey/README.md).
  90. Also check out our [llm-webchat](https://github.com/imbue-ai/llm-webchat) web UI that can be used together with Latchkey!
  91. ## Demo
  92. ![Image](https://github.com/user-attachments/assets/953eae6e-35ab-4d64-91f3-98b6843c502d)
  93. ## Direct usage
  94. Let's revisit the initial example:
  95. ```bash
  96. latchkey curl -X POST 'https://slack.com/api/conversations.create' \
  97. -H 'Content-Type: application/json' \
  98. -d '{"name":"something-urgent"}'
  99. ```
  100. Notice that `-H 'Authorization: Bearer ...'` is absent. This is
  101. because Latchkey injects stored credentials automatically. To
  102. set up credentials for a service (Slack in this example), run:
  103. ```bash
  104. latchkey auth browser slack
  105. ```
  106. This opens the browser with a login screen. After you log in, Latchkey extracts
  107. the necessary API credentials from the browser session, closes the browser, and
  108. stores the credentials so that they can be reused.
  109. Alternatively, you can provide credentials manually:
  110. ```bash
  111. latchkey auth set slack -H "Authorization: Bearer xoxb-your-token"
  112. ```
  113. `latchkey curl` passes your arguments straight through to `curl`
  114. so you can use the same interface you are used to. The return
  115. code, stdout and stderr are passed back from curl to the caller
  116. of `latchkey`.
  117. ### Multiple accounts
  118. Credentials for a service can be stored under several accounts.
  119. An account is a string that uniquely identifies the account
  120. behind the credentials - typically an e-mail, but for some
  121. services it may be an id. Use the global `--account` option to
  122. select one:
  123. ```bash
  124. # Store credentials for a specific account.
  125. latchkey --account bob@example.com auth set slack -H "Authorization: Bearer xoxb-..."
  126. # Use them in a request.
  127. latchkey --account bob@example.com curl https://slack.com/api/auth.test
  128. ```
  129. When `--account` is omitted, the single stored account is used
  130. automatically. If a service has more than one stored account,
  131. `--account` becomes required. Credentials stored without an
  132. account live under a "default" account (empty string, `""`).
  133. Browser logins (`latchkey auth browser`) determine the account
  134. automatically. The `--account` option here merely allows users
  135. to specify which existing OAuth client configuration to use for
  136. the login (selecting one associated with an existing account) if
  137. needed.
  138. The only exceptions are services that cannot determine the
  139. account for the completed browser login. For those, `--account`
  140. also names the account the new credentials are stored under. All
  141. services registered at runtime (see "Entirely new services"
  142. below) fall into this category. Whether a service falls into
  143. this category is indicated by the `detectsLoginAccount`
  144. capability flag in the output of `latchkey services info`.
  145. ### Self-hosted services
  146. For services that can be self-hosted, like GitLab, first make Latchkey aware of your service instance:
  147. ```bash
  148. latchkey services register my-gitlab-instance --service-family=gitlab --base-api-url="https://gitlab.example.com/api/v4/"
  149. ```
  150. Then continue as usual.
  151. ```bash
  152. latchkey auth set my-gitlab-instance -H "PRIVATE-TOKEN: <token>"
  153. # Agents can then call the API.
  154. latchkey curl https://gitlab.example.com/api/v4/user
  155. ```
  156. ### Entirely new services
  157. If you want to use Latchkey with a service that is not in the
  158. list of supported built-in services, you can still use the
  159. mechanism described above to register a new service at runtime:
  160. ```bash
  161. latchkey services register mastodon --base-api-url="https://mastodon.social/api/v1/"
  162. latchkey auth set mastodon -H "Authorization: Bearer <your_access_token>"
  163. # Agents can then call the service:
  164. latchkey curl https://mastodon.social/api/v1/timelines/public?limit=2
  165. ```
  166. You can also configure browser login flows for registered services. For details,
  167. see `latchkey services register --help`.
  168. ### Capability flags
  169. Among other things, `latchkey services info <service_name>` shows a list of capabilities:
  170. - `detectsLoginAccount`: Whether `latchkey auth browser` automatically resolves the account upon success.
  171. - `systemBrowserLogin`: When true, `latchkey auth browser` accepts the `--system`
  172. flag to open the user's system browser instead of the browser Latchkey controls.
  173. ### Plugins
  174. It is also possible to add support for a new service by
  175. installing a plugin that implements it. A Latchkey plugin is
  176. a git repository; installation is a matter of running `git
  177. clone` in `~/.latchkey/plugins/`. For more details, see the
  178. [plugins docs](./docs/plugins.md).
  179. ### MCP wrappers
  180. You might notice that in the list of built-in services
  181. (`latchkey services list`), many have the `-mcp` suffix. In
  182. those cases, we just treat the MCP servers as plain JSON-based
  183. HTTP APIs that happen to have good, standardized browser login
  184. flows.
  185. ### Indirect credentials
  186. Some services can't express their credentials as static curl
  187. arguments. For example:
  188. - AWS requires a signature that changes with each request.
  189. - Telegram expects bot tokens to be directly part of the URL.
  190. In similar cases, when supported, you can use the `latchkey auth set-nocurl` command, e.g.
  191. like this:
  192. ```bash
  193. latchkey auth set-nocurl aws <access-key-id> <secret-access-key>
  194. ```
  195. Latchkey will then modify subsequent `latchkey curl` requests as
  196. needed. You can find more information (including the expected
  197. signature) by calling `latchkey services info <service_name>`.
  198. ### Remembering API credentials
  199. Your API credentials and browser state are encrypted and stored
  200. by default under `~/.latchkey`. They are never transmitted
  201. anywhere beyond the endpoints specified by the actual curl
  202. calls.
  203. ### Inspecting the status of stored credentials
  204. Calling `latchkey services info <service_name>` will show
  205. information about the service, including a `credentials` object
  206. keyed by account (the default account uses the empty string).
  207. Each entry reports a credentials status of:
  208. - `invalid`
  209. - `valid`
  210. - `unknown` (for user-registered services)
  211. When it is known that the credentials stop working after some
  212. date the entry also carries a `validUntil` timestamp.
  213. A service with no stored credentials shows an empty `credentials`
  214. object.
  215. ### Clearing credentials
  216. Remembered API credentials can expire. The caller of `latchkey
  217. curl` will typically notice this because the calls will start returning
  218. HTTP 401 or 403. To verify that, first call `latchkey services info`, e.g.:
  219. ```bash
  220. latchkey services info discord
  221. ```
  222. If the credentials status is `invalid`, it means the Unauthorized/Forbidden
  223. responses are caused by invalid or expired credentials rather than insufficient
  224. permissions. In that case, log in again:
  225. ```bash
  226. latchkey auth browser discord
  227. ```
  228. Or alternatively:
  229. ```bash
  230. latchkey auth set discord -H "Authorization: ..."
  231. ```
  232. ### Clearing credentials and logins
  233. In case you want to remove stored API credentials, use the `auth clear` subcommand.
  234. ```bash
  235. latchkey auth clear discord
  236. ```
  237. To clear all stored data (both the credential store and browser state file), run:
  238. ```bash
  239. latchkey auth clear
  240. ```
  241. ### Re-encrypting credentials
  242. If you want to export your stored credentials encrypted with
  243. a different key or containing only some of the credentials (for
  244. example to move them to another machine) , use the `auth re-encrypt`
  245. subcommand. Use `--services` to limit the export to certain services
  246. and the global `--account` option to export only the credentials of
  247. a single account.
  248. ### Permissions
  249. Optionally, you can specify rules for approving / rejecting
  250. requests by creating the `permissions.json` file in the Latchkey
  251. directory (`~/.latchkey/permissions.json`). For example:
  252. ```json
  253. {
  254. "rules": [
  255. {"google-gmail-api": ["google-gmail-read-all"]},
  256. {"slack-api": ["slack-read-all"]}
  257. ]
  258. }
  259. ```
  260. This would mean that:
  261. - When accessing the Gmail or the Slack API, only read actions are allowed.
  262. - No requests are allowed to any other domains.
  263. Rules can also depend on the used account which Latchkey injects as the
  264. `account` custom metadata key. See [the underlying library's docs](https://github.com/imbue-ai/detent#custom-metadata) for more details.
  265. Ideally make the file read-only: `chmod -w ~/.latchkey/permissions.json`.
  266. In the gateway mode, you can use [permission overrides](#permission-overrides) to let
  267. different callers claim different permission policies.
  268. For more details, check out the [permission docs](https://docs.imbue.com/latchkey/basics/permissions).
  269. ### Gateway mode
  270. People sometimes run agents in isolated sandboxes for higher
  271. security. Using gateway mode lets you extend the isolation
  272. to Latchkey itself. Run this to start a Latchkey server on the
  273. machine where your main configuration lives:
  274. ```bash
  275. # Listens on localhost:1989 by default.
  276. # You can override this using the LATCHKEY_GATEWAY_LISTEN_HOST
  277. # and LATCHKEY_GATEWAY_LISTEN_PORT environment variables.
  278. latchkey gateway
  279. ```
  280. Suppose you run an agent inside a container on the same machine,
  281. with the gateway port mapped into the container. Then setting
  282. `LATCHKEY_GATEWAY=http://localhost:1989` in your container will
  283. route your agent's `latchkey` calls to the host Latchkey
  284. (limited to a selected safe subset of commands). That way the
  285. agent won't be able to tamper with your Latchkey configuration
  286. while still being able to use Latchkey itself as intended.
  287. #### Password
  288. You can additionally protect the gateway with a shared password.
  289. Set `LATCHKEY_GATEWAY_LISTEN_PASSWORD` on the machine running
  290. `latchkey gateway` (the value the server requires) and
  291. `LATCHKEY_GATEWAY_PASSWORD` on the client (the value the CLI
  292. sends). When the two match, the request is accepted; otherwise
  293. the gateway responds with `401`. The password is carried in the
  294. `X-Latchkey-Gateway-Password` header and is never forwarded
  295. upstream, so it stays internal to Latchkey.
  296. #### Permission overrides
  297. Individual gateway requests can also override which
  298. `permissions.json` file the gateway consults by sending a
  299. `X-Latchkey-Gateway-Permissions-Override` header. The header
  300. value is a minimal HS256 JWT whose only payload field,
  301. `permissionsConfig`, is an absolute path. The signing key is
  302. derived from your Latchkey encryption key, so only someone with
  303. access to that key can mint valid pointers. Generate one with:
  304. ```bash
  305. latchkey gateway create-jwt /etc/latchkey/permissions-readonly.json
  306. ```
  307. (Pass `--no-validate` to skip the existence check, e.g. when
  308. the target file lives on a different machine.) The gateway
  309. responds with `401` for invalid or missing-signature JWTs and
  310. with `400` when the JWT is valid but the referenced file does
  311. not exist.
  312. On the client side, set `LATCHKEY_GATEWAY_PERMISSIONS_OVERRIDE`
  313. to the JWT and the CLI will attach it to every outgoing gateway
  314. request automatically (analogous to `LATCHKEY_GATEWAY_PASSWORD`).
  315. #### Extensions
  316. You can extend the gateway with your own HTTP endpoints. For
  317. details, see the [extensions docs](./docs/extensions.md).
  318. ### Other configuration
  319. You can set these environment variables to override certain
  320. defaults:
  321. - `LATCHKEY_DIRECTORY`: path to the directory where Latchkey stores its data (defaults to `~/.latchkey`)
  322. - `LATCHKEY_CURL`: path to the curl binary
  323. - `LATCHKEY_KEYRING_SERVICE_NAME`, `LATCHKEY_KEYRING_ACCOUNT_NAME`: identifiers that are used to store the encryption password in your keyring
  324. - `LATCHKEY_ENCRYPTION_KEY`: override the encryption key, e.g. when a keyring is not available. Example: `export LATCHKEY_ENCRYPTION_KEY="$(openssl rand -base64 32)"`
  325. - `LATCHKEY_DISABLE_BROWSER`: when set to a non-empty value, disables the browser login flow; commands that would trigger a browser login (`auth browser`, `auth browser-prepare`) will fail with an error instead
  326. - `LATCHKEY_EPHEMERAL_BROWSER`: when set to a non-empty value, browser flows operate similarly to the browser incognito mode. Useful when logging into multiple accounts.
  327. - `LATCHKEY_DISABLE_COUNTING`: when set to a non-empty value, disables daily usage counting.
  328. - `LATCHKEY_DISABLE_CREDENTIALS_REFRESH`: when set to a non-empty value, expired credentials are never refreshed. (Useful when the credentials are shared and refreshing in one place would risk exhausting the refresh token for the other one.)
  329. - `LATCHKEY_PERMISSIONS_CONFIG`: override the `permissions.json` location.
  330. - `LATCHKEY_PERMISSIONS_DO_NOT_USE_BUILTIN_SCHEMAS`: do not use the built-in permission definitions.
  331. - `LATCHKEY_PASSTHROUGH_UNKNOWN`: if set, Latchkey will forward requests (via `latchkey curl` or gateway) even if no credentials are injected.
  332. - `LATCHKEY_HIDE_BUILTIN_SERVICES`: comma-separated list of built-in service names to disable/hide.
  333. - `LATCHKEY_GATEWAY`: when set to a base URL (e.g. `http://localhost:1989`), the CLI delegates commands to a remote Latchkey gateway instead of running them locally. Commands that change local state (`auth set`, `auth clear`, `auth re-encrypt`, `services register`, `ensure-browser`, `gateway`) cannot run in this mode.
  334. - `LATCHKEY_GATEWAY_LISTEN_HOST`, `LATCHKEY_GATEWAY_LISTEN_PORT`: default address and port the local `latchkey gateway` command binds to when `--host` / `--port` are not supplied (defaults: `localhost`, `1989`). Distinct from `LATCHKEY_GATEWAY`, which configures a *remote* gateway URL.
  335. - `LATCHKEY_GATEWAY_PASSWORD`: optional shared secret used by the client side. When set together with `LATCHKEY_GATEWAY`, the CLI sends the value in the `X-Latchkey-Gateway-Password` header on every outgoing gateway request.
  336. - `LATCHKEY_GATEWAY_LISTEN_PASSWORD`: optional shared secret used by the server side. When set, `latchkey gateway` rejects (with `401`) any request that does not present the same value in the `X-Latchkey-Gateway-Password` header. The header is stripped before requests are forwarded upstream.
  337. - `LATCHKEY_GATEWAY_PERMISSIONS_OVERRIDE`: optional permissions-override JWT (see `latchkey gateway create-jwt`) used by the client side. When set together with `LATCHKEY_GATEWAY`, the CLI sends the value in the `X-Latchkey-Gateway-Permissions-Override` header on every outgoing gateway request, causing the remote gateway to enforce the permissions.json file referenced by the JWT instead of its default one.
  338. - `LATCHKEY_APP_NAME_PREFIX`: prefix used for the app, project, and OAuth client names that Latchkey creates on your behalf inside third-party consoles (defaults to `Latchkey`).
  339. - `LATCHKEY_DIAGNOSTIC_HEADERS`: if set, Latchkey adds special headers with diagnostic information to the outgoing requests. This currently includes `X-Latchkey-Matched-Service`, indicating the service that Latchkey matched the request to and injected credentials for.
  340. All of the above settings, except for `LATCHKEY_DIRECTORY`,
  341. `LATCHKEY_ENCRYPTION_KEY`, `LATCHKEY_GATEWAY_PASSWORD`,
  342. `LATCHKEY_GATEWAY_LISTEN_PASSWORD`, and
  343. `LATCHKEY_GATEWAY_PERMISSIONS_OVERRIDE`, can alternatively be
  344. specified in the `settings` section of `config.json` inside the
  345. Latchkey directory. In case of a clash, environment variables
  346. override `config.json` values.
  347. ```json
  348. {
  349. "settings": {
  350. "curlCommand": "/usr/local/bin/curl",
  351. "keyringServiceName": "latchkey",
  352. "keyringAccountName": "encryption-key",
  353. "browserDisabled": false,
  354. "browserEphemeral": false,
  355. "countingDisabled": true,
  356. "permissionsConfig": "/etc/latchkey/permissions.json",
  357. "permissionsDoNotUseBuiltinSchemas": false,
  358. "passthroughUnknown": false,
  359. "hideBuiltinServices": ["telegram", "yelp"],
  360. "gateway": "http://localhost:1989",
  361. "gatewayListenHost": "localhost",
  362. "gatewayListenPort": 1989,
  363. "appNamePrefix": "Latchkey"
  364. }
  365. }
  366. ```
  367. #### Passing settings through a file descriptor
  368. Environment variables can be read by other processes running as
  369. the same user and are inherited by child processes. To avoid
  370. exposing secrets such as `LATCHKEY_ENCRYPTION_KEY`, you can set
  371. `LATCHKEY_ENV_OVERRIDES_FD` to the number of an inherited file
  372. descriptor. Latchkey reads a JSON object from it at startup
  373. and then closes it. The object maps the names of any of the
  374. environment variables above to their (string) values:
  375. ```
  376. latchkey curl https://api.github.com/user 3< <(printf '{"LATCHKEY_ENCRYPTION_KEY": "%s"}' "$KEY")
  377. ```
  378. (with `LATCHKEY_ENV_OVERRIDES_FD=3` set in the environment).
  379. The values follow the same rules as the corresponding
  380. environment variables and take precedence over both the actual
  381. environment and `config.json`.
  382. ### Troubleshooting
  383. For debugging purposes, the global `--dry-run` option (currently
  384. supported only by `latchkey curl`) resolves the request
  385. as usual but stops short of sending it, printing a diagnostic
  386. JSON on stdout instead:
  387. ```bash
  388. latchkey --dry-run curl https://slack.com/api/auth.test
  389. ```
  390. ```json
  391. {
  392. "credentialsInjected": true,
  393. "service": "slack"
  394. }
  395. ```
  396. ## Disclaimers
  397. - This is still a work in progress.
  398. - Latchkey has been created with the help of AI-assisted coding tools with careful human curation.
  399. - Invoking `latchkey auth browser ...` can sometimes have side effects in the form of
  400. new API keys being created in your accounts (through browser automation).
  401. - Using agents for automated access may be prohibited by some services' ToS.
  402. - Unless `LATCHKEY_DISABLE_COUNTING` is set, once a day, when invoking `latchkey`, a GET request is sent to [goatcounter.com](https://goatcounter.com). We don't store any sort of private information and don't track anything beyond a simple daily count of active users.
  403. - We reserve the right to change the license of future releases of Latchkey.
  404. - Latchkey was not tested on Windows.
  405. ## Currently supported services
  406. Latchkey currently offers varying levels of support for the following services:
  407. Airtable, Any.do, Asana, Atlassian, Attio, AWS, beehiiv, Buildkite, Cal.com, Calendly,
  408. Canva, Discord, Dropbox, Fathom, Figma, Gamma, GitHub, GitLab, Gmail,
  409. Google Analytics, Google Calendar, Google Docs, Google Drive, Google Sheets,
  410. Granola, invideo, Linear, Linktree, Mailchimp, Neon, Netlify, Notion, Otter.ai,
  411. PayPal, Peloton, PostHog, Ramp, Readwise, Sentry, Slack, Stripe, Supabase,
  412. Telegram, TickTick, Todoist, Trello, Vercel, Webflow, Wix, Yelp, Zoom, and more.

Ratings and comments

Sign in to rate this skill.

Sign in

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