DEV Community: FreeTier

Give your AI agent paid tools with x402 and MCP: a working example

FreeTier — Mon, 26 Oct 2026 05:50:01 +0000

Disclosure: I run the API used in this example (FreeTier Agent API), so treat this as a vendor tutorial. The article was drafted with AI assistance and checked by hand. Every output below was captured from the live service on 2026-10-25; nothing is made up.

What this shows

Many agent tools are small lookups: "does this domain have DMARC?", "when does this cert expire?", "what are the coordinates of this address?". Building and hosting each one yourself is overkill; paying a monthly SaaS plan for 20 calls is too. x402 is an HTTP-native way to pay per call, and MCP is how assistants like Claude and Cursor discover tools. This post connects the two with a real endpoint you can try for free.

x402 in one paragraph

The server answers an unpaid request with HTTP 402 Payment Required plus machine-readable payment terms. An x402 client signs a USDC transfer authorization on Base (no gas needed by the payer; a facilitator settles it) and repeats the request with a PAYMENT-SIGNATURE header. The server verifies, does the work, settles, and returns the result.

Here is the real 402 challenge for an SSL-certificate lookup (decoded from the PAYMENT-REQUIRED header, trimmed):

curl -si "https://freetier-agent-api.pages.dev/api/ssl-cert?domain=dev.to&nofree=1"

{
 "scheme": "exact",
 "network": "eip155:8453",
 "amount": "5000",
 "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
 "payTo": "0x165Eb3dC3E98403ecB1141e90400F5e71806554B",
 "maxTimeoutSeconds": 300
}

amount is in USDC base units (6 decimals), so 5000 = $0.005. nofree=1 skips the free trial so you can see the challenge.

Connect the MCP server

The same routes are exposed as MCP tools at https://freetier-agent-api.pages.dev/mcp (Streamable HTTP).

Claude Code

claude mcp add --transport http freetier https://freetier-agent-api.pages.dev/mcp

Cursor (~/.cursor/mcp.json)

{ "mcpServers": { "freetier": { "url": "https://freetier-agent-api.pages.dev/mcp" } } }

Claude Desktop (claude_desktop_config.json, via the mcp-remote bridge)

{ "mcpServers": { "freetier": { "command": "npx", "args": ["-y", "mcp-remote", "https://freetier-agent-api.pages.dev/mcp"] } } }

Full copy-paste recipes, including how to add a paid key: https://freetier-agent-api.pages.dev/recipes

Then ask, for example: "Check the DNS, SPF and DMARC records for dev.to and tell me whether its mail setup has any warnings."

A working Node example (no SDK)

MCP over HTTP is JSON-RPC, so plain fetch works (Node 18+):

// mcp_call.mjs
const MCP = "https://freetier-agent-api.pages.dev/mcp";
const rpc = async (method, params, id = 1) => {
  const r = await fetch(MCP, { method: "POST",
    headers: { "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
    body: JSON.stringify({ jsonrpc: "2.0", id, method, params }) });
  return r.json();
};
const res = await rpc("tools/call", { name: "dns", arguments: { domain: "dev.to" } });
if (res.result.isError) console.log("Payment required:", JSON.stringify(res.result.structuredContent.accepts[0], null, 2));
else console.log(res.result.content[0].text);

Real output of node mcp_call.mjs (this was the free call; TXT records trimmed):

{
 "domain": "dev.to",
 "status": "NOERROR",
 "exists": true,
 "dnssec_validated": false,
 "records": {
  "A": [{ "data": "151.101.66.217", "ttl": 160 }, "... 3 more"],
  "MX": [{ "data": "1 smtp.google.com.", "ttl": 300, "priority": 1, "host": "smtp.google.com" }],
  "NS": [{ "data": "jill.ns.cloudflare.com.", "ttl": 86400 }, { "data": "josh.ns.cloudflare.com.", "ttl": 86400 }]
 },
 "mail": {
  "accepts_mail": true,
  "mx_hosts": ["smtp.google.com"],
  "spf": "v=spf1 a mx include:_spf.google.com include:sendgrid.net include:servers.mcsv.net include:shops.shopify.com ~all",
  "spf_all": "~all",
  "spf_multiple": false,
  "dmarc_policy": "reject",
  "dmarc_pct": 100,
  "warnings": []
 },
 "resolver": "cloudflare"
}

The second call from the same caller gets the payment branch instead: isError: true with the x402 PaymentRequired object in structuredContent. An x402-aware MCP client signs it and repeats the call with params._meta["x402/payment"]; the receipt comes back in result._meta["x402/payment-response"].

Paying over plain HTTP

With a dedicated, low-balance Base wallet holding a little USDC:

// npm i @x402/fetch @x402/evm viem
import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.EVM_PRIVATE_KEY);
const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: "eip155:8453", client: new ExactEvmScheme(account) }],
});
const res = await fetchWithPayment("https://freetier-agent-api.pages.dev/api/dns?domain=dev.to");
console.log(await res.json());

I am not pasting a paid response here because it is the same JSON as above plus a payment receipt header; I did not want to show anything I had not run for this post.

Limits (read these)

1 free call per route per caller. Callers are identified by a hash of IP + user agent, so it is a trial, not a quota.
Costs: dns $0.0025, domain-whois $0.005, ssl-cert $0.005, geocode $0.0015 per call. Failed calls (400/502) are not charged.
Data sources: DNS via Cloudflare/Google DNS-over-HTTPS; WHOIS via official RDAP servers (some ccTLDs such as .de and .dk have no public RDAP and return a clear error); SSL from Certificate Transparency logs (shows issued certs, not what a server is serving right now); geocoding from OpenStreetMap Nominatim (rate-limited to 1 req/s, cached, ODbL attribution in every response).
Desktop chat apps do not sign x402 payments. In Claude Desktop/Cursor you either stay on free calls or use a prepaid card key (X-License-Key header); wallet payments need an x402 client like the one above.
Use a separate wallet with a small balance for any agent that can spend.

Resources

x402 protocol: https://x402.org
Model Context Protocol: https://modelcontextprotocol.io
Setup recipes used above: https://freetier-agent-api.pages.dev/recipes
OpenAPI spec of the example API: https://freetier-agent-api.pages.dev/openapi.json

Invoice PDF to JSON for AI agents: $0.003 per page with x402, or by card

FreeTier — Sat, 24 Oct 2026 20:53:42 +0000

Agents that handle bills, receipts or expense reports keep running into the same problem: the invoice is a PDF, and the agent needs fields it can trust: who sent it, the invoice number, the totals, the line items. This post shows a small HTTP API that does that one job and charges per page, either in USDC over x402 or by card with a prepaid credit pack.

Full disclosure: I run this API, and this post was drafted with AI assistance and checked by hand.

One real call

Every caller gets one free call per route, so you can try it with no wallet and no signup. This is the exact request I ran while writing this post, on a public sample invoice from the open-source invoice2data test set:

curl -s -X POST https://freetier-agent-api.pages.dev/api/invoice-json \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://raw.githubusercontent.com/invoice-x/invoice2data/master/tests/compare/AzureInterior.pdf"}'

You can send a url (PDF, PNG, JPEG or WebP, max 8 MB), plain text, or file_base64 + mime_type in a POST body.

What came back (trimmed)

{
  "invoice_number": { "value": "INV/2023/03/0008", "quote": "Invoice INV/2023/03/0008", "confidence": 0.95 },
  "issue_date": { "value": "2023-03-20", "quote": "Invoice Date:03/20/2023", "confidence": 0.9 },
  "currency": { "value": "USD", "quote": "$ 42.00", "confidence": 0.9 },
  "totals": {
    "subtotal":  { "value": 262.9,  "quote": "Subtotal $ 262.90", "confidence": 0.98 },
    "vat_total": { "value": 16.94,  "quote": "Tax 15% on $ 112.90 $ 16.94", "confidence": 0.98 },
    "total":     { "value": 279.84, "quote": "Total $ 279.84", "confidence": 0.98 }
  },
  "line_items": [
    { "description": "[FURN_7777] Office Chair", "quantity": 1, "unit_price": 70, "amount": 70, "vat_rate": 15,
      "quote": "[FURN_7777] Office Chair 1.00 Units 70.00 0.00 15.00% $ 70.00", "confidence": 0.85 }
  ],
  "checks": {
    "subtotal_plus_vat_equals_total": true,
    "line_items_sum_equals_subtotal_or_total": true,
    "vat_breakdown_sum_equals_vat_total": true,
    "due_date_not_before_issue_date": true
  },
  "overall_confidence": 0.94,
  "pages": 1,
  "billed_usd": 0.003
}

The parts I care most about as an agent builder:

Every field carries the verbatim quote it came from. Your code (or a human) can check a value against the document in one string search.
Confidence is mechanical, not vibes. It is higher when the quote is found verbatim in the document text and the value matches the quote.
Totals are checked arithmetically. The checks block tells you whether subtotal + VAT = total and whether the line items add up, so an agent can route anything that fails to a human.

It is not perfect, and the response says so. On this demo invoice (an Odoo template with two addresses near the top), the vendor and customer roles came out mixed up. The quotes make that easy to spot, but you should still check the fields that matter before you pay anything.

Paying per call with x402 (USDC on Base)

After the free call, the route answers 402 Payment Required with the price: $0.003 per page (max 10 pages per call). With @x402/fetch the payment is handled for you:

// npm i @x402/fetch @x402/evm viem
import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.EVM_PRIVATE_KEY); // wallet with USDC on Base
const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: "eip155:8453", client: new ExactEvmScheme(account) }],
});
const res = await fetchWithPayment("https://freetier-agent-api.pages.dev/api/invoice-json", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ url: "https://raw.githubusercontent.com/invoice-x/invoice2data/master/tests/compare/AzureInterior.pdf" }),
});
console.log(await res.json());

Failed calls (a bad URL, a document it cannot read) are not charged.

Pay by card instead (no wallet)

If you don't want to hold USDC, there is a prepaid credit pack on Gumroad: Agent Extraction API - Call Pack (1,000 credits for $3, 5,000 for $12, 20,000 for $40). You get a license key and send it as a header:

curl -s -X POST https://freetier-agent-api.pages.dev/api/invoice-json \
  -H 'X-License-Key: YOUR-LICENSE-KEY' \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://raw.githubusercontent.com/invoice-x/invoice2data/master/tests/compare/AzureInterior.pdf"}'

One credit is $0.001, so an invoice page costs 3 credits. The X-Credits-Remaining response header shows your balance, and failed calls are not charged.

Limits

LLM extraction can misread layouts; check important values (the quotes make that quick).
Scanned PDFs need image input.
Documents are processed in memory and not stored. Extraction runs on Cloudflare Workers AI, not a third-party LLM API.
Max 10 pages per call.

Other routes on the same API

The same API (and the same card credits) also covers token-risk (ERC-20 risk flags with evidence), site-contacts (role emails and phones from a company site) and page-rag (web page to Markdown + RAG chunks). There is also an MCP endpoint at /mcp and an OpenAPI spec at /openapi.json.

The listing is verified on PayAPI Market: that means PayAPI Market made one settled $0.001 test payment to one route (on-chain receipt). It is not an audit.

Docs and the full schema: freetier-agent-api.pages.dev/products/invoice-json

Disclosure: this article was drafted with AI assistance; I run this API.

Cheapest LLM APIs per 1M tokens (Oct 2026): 20 models compared, plus free tiers

FreeTier — Sat, 24 Oct 2026 17:05:02 +0000

Disclosure: I wrote this with help from AI tools and checked every number against our own data files, which link each provider page. The PDF, the API and the directory are my own products; the API and the dataset are paid.

All prices below are standard list prices in USD per 1 million tokens. I checked them by hand on each provider's official pricing page on 2026-10-17 (OpenAI, Anthropic, Google, xAI, DeepSeek). Providers change prices often, so confirm on the linked pricing page before you commit real spend.

To compare models with one number, I use a "1M+1M job": the cost of 1M input tokens plus 1M output tokens. The list is sorted from cheapest to most expensive.

The 20 models, cheapest first

gpt-5-nano (OpenAI): $0.05 in / $0.4 out, 1M+1M job = $0.45
gemini-2.5-flash-lite (Google): $0.1 in / $0.4 out, 1M+1M job = $0.50 (free tier)
gpt-6-luna (OpenAI): $0.1 in / $0.5 out, 1M+1M job = $0.60
Claude Haiku 5.5 (Anthropic): $0.1 in / $0.5 out, 1M+1M job = $0.60 (prompts up to 100k tokens; $0.50/$2.50 above)
gpt-5.6-luna (OpenAI): $0.2 in / $1.2 out, 1M+1M job = $1.40
deepseek-flash (DeepSeek): $0.3 in / $1.2 out, 1M+1M job = $1.50 (peak price; off-peak is half)
gemini-3.1-flash-lite (Google): $0.25 in / $1.5 out, 1M+1M job = $1.75 (text input; free tier)
gpt-4.1-mini (OpenAI): $0.4 in / $1.6 out, 1M+1M job = $2.00
gemini-3.5-flash-lite (Google): $0.3 in / $2.5 out, 1M+1M job = $2.80 (free tier)
gemini-2.5-flash (Google): $0.3 in / $2.5 out, 1M+1M job = $2.80 (text input; free tier)
gemini-3.8-flash (Google): $0.75 in / $3.75 out, 1M+1M job = $4.50 (until 31 Dec 2026, then $1.50/$7.50; free tier)
gpt-5.4-mini (OpenAI): $0.75 in / $4.5 out, 1M+1M job = $5.25
deepseek-v4-pro (DeepSeek): $1.32 in / $3.96 out, 1M+1M job = $5.28 (peak price; off-peak is half)
Claude Haiku 4.5 (Anthropic): $1 in / $5 out, 1M+1M job = $6.00
grok-4.7 (xAI): $2 in / $6 out, 1M+1M job = $8.00 (500k context)
gpt-6.1-sol (OpenAI): $2 in / $10 out, 1M+1M job = $12.00
Claude Sonnet 5.5 (Anthropic): $2 in / $10 out, 1M+1M job = $12.00
gemini-4-argon (Google): $2 in / $10 out, 1M+1M job = $12.00 (until 30 Nov 2026, then $4/$20; no free tier)
Claude Opus 5.5 (Anthropic): $4 in / $20 out, 1M+1M job = $24.00
gpt-6-astra (OpenAI): $10 in / $50 out, 1M+1M job = $60.00

What the numbers say

Four models cost $0.60 or less per 1M+1M job: gpt-5-nano ($0.45), gemini-2.5-flash-lite ($0.50), gpt-6-luna ($0.60) and Claude Haiku 5.5 ($0.60, for prompts up to 100k tokens).
The most expensive model in the list, gpt-6-astra ($60.00), costs about 133 times as much as the cheapest, gpt-5-nano ($0.45).
Output tokens cost 3 to 8.3 times as much as input tokens. If your app writes long answers, look at the output price first.
DeepSeek lists peak prices; its off-peak price is half. Two Google prices are introductory: gemini-3.8-flash rises to $1.50/$7.50 after 31 Dec 2026 and gemini-4-argon to $4/$20 after 30 Nov 2026.
A simple way to save: send classification, extraction and short rewrites to a small model, and keep the large model for the hard steps.

Free tiers worth knowing

Several Google Gemini models in the list above have a free tier on the Gemini API. These AI API free tiers are described on each provider's own page (checked 17 Oct 2026; limits change, so follow the source link):

Cerebras - Llama / Qwen models: Free tier with rate limits (source)
Cloudflare Workers AI - LLMs (Llama, Mistral, etc.): 10,000 Neurons/day free (source)
Cloudflare Workers AI - Whisper / image models: 10,000 Neurons/day free (source)
Cohere - Command models: Trial key: 1,000 API calls/month; Command A 20 req/min (source)
Cohere - Embed / Rerank: Trial key: 1,000 API calls/month total (source)
Deepgram - Speech-to-text / TTS: $200 free credit, then pay-as-you-go (source)
ElevenLabs - Text-to-speech: 10k credits/month, 3 Studio projects (no commercial license) (source)
Google AI Studio (Gemini API) - Gemini Flash models: Free tier with rate limits (source)
Google AI Studio (Gemini API) - Gemini Pro models: Free tier availability varies by model (source)
Groq - Llama models: Free tier with per-model rate limits (source)
Groq - Whisper (speech-to-text): whisper-large-v3: 20 requests/min, 2K requests/day (source)
Mistral AI - Mistral Embed: Free experiment tier (source)
Mistral AI - Mistral models (La Plateforme): Free experiment tier (source)
NVIDIA NIM (build.nvidia.com) - Hosted model endpoints: Free API access for prototyping (developer program) (source)
OpenRouter - Models tagged :free: Free variants with daily request limits (source)
Voyage AI - Embedding models: First 200M tokens free per account (voyage-4 family) (source)

Get the cheat sheet and the data

Free PDF cheat sheet: these 20 prices plus the free tiers on two pages. Free; you leave an email address to get it.
FreeTier Agent API: your code or agent can look up prices for about 3,000 models (/api/llm-pricing, $0.02 per call) and estimate the cost of a job (/api/llm-cost, $0.01 per call), paid per call in USDC over x402. No signup or API key. A free sample is at /api/llm-pricing/sample. The API uses the open litellm price table (MIT), which can lag behind the official pages.
Tools for Agents: a free directory of more than 8,500 tools for AI agents, including AI dev tools with free tiers and a page of model prices.
AI Model Pricing + Free Tiers dataset ($5, paid): about 3,000 model prices from the litellm table plus 59 free tiers, as CSV and JSON.

How to let your AI agent pay per API call with x402 (about 10 lines of code)

FreeTier — Sat, 24 Oct 2026 09:05:02 +0000

Disclosure: I wrote this with help from AI tools. The FreeTier Agent API, the directory and the PDF are my own projects; the API is paid per call. The code below uses the open-source x402 client packages, which I do not maintain.

More and more APIs answer an unpaid request with HTTP 402 Payment Required and a machine-readable price. That is the x402 protocol. Your agent reads the price, signs a small USDC payment, sends the request again and gets the data. There is no signup, no API key and no monthly plan. This guide shows the client side: how to let your own script or agent pay per call.

What happens on the wire

The agent calls the endpoint as usual.
The server answers 402. The PAYMENT-REQUIRED header (x402 v2) says how much, in which token, on which network and to which address.
The client signs a USDC transfer authorization (EIP-3009) with its wallet key. Nothing is sent onchain by the client itself.
The client repeats the request with a PAYMENT-SIGNATURE header.
The server has a facilitator verify and settle the payment, then returns the data and a PAYMENT-RESPONSE receipt header.

The code (Node 20+, TypeScript or plain ES modules)

Install the official client packages:

npm install @x402/fetch @x402/evm viem

Then the whole client is about 10 lines:

import { x402Client, wrapFetchWithPayment } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";

const signer = privateKeyToAccount(process.env.EVM_PRIVATE_KEY);
const client = new x402Client();
client.register("eip155:*", new ExactEvmScheme(signer));

const payFetch = wrapFetchWithPayment(fetch, client);
const res = await payFetch("https://freetier-agent-api.pages.dev/api/country?q=DK");
console.log(res.status, await res.json());

I ran this code (with a freshly generated key instead of an environment variable) on 18 Oct 2026 (@x402/fetch and @x402/evm 2.28.0) against a live endpoint, using a fresh wallet with no funds. The library read the 402, signed a payment and retried, and the facilitator rejected it with "insufficient balance". That is the expected result for an empty wallet, and it shows the client side (reading the price, signing, retrying) works. With USDC on Base in the wallet, the same call returns the data.

Rules I would follow before giving an agent a wallet

Use a separate hot wallet with a small balance, for example a few dollars of USDC on Base. Never use your main wallet key.
Set a spending limit. The x402 client has spend controls (setSpendControls with maxAmountPerPayment in the official examples), so a buggy loop cannot pay more than you allow per call.
Log every PAYMENT-RESPONSE header. It is your receipt.
Prefer endpoints with a free sample, so you can test the response format before you pay.

Endpoints you can try it on

Our own FreeTier Agent API has 18 pay-per-call endpoints, from $0.002 to $0.05 per call, plus 6 full dataset downloads ($5 to $9). Examples:

/api/country, /api/holidays, /api/currency: country facts, public holidays and ECB exchange rates, $0.002 per call
/api/email-verify: email syntax, domain MX record and disposable-domain check without sending mail, $0.005
/api/llm-pricing: prices for about 3,000 AI models, $0.02; /api/llm-cost: cost estimate for a job, $0.01
/api/mcp-servers: search 4,259 MCP servers, $0.02
/api/extract-json: messy text plus a JSON Schema in, clean JSON out, $0.015
Free samples, no payment: /api/llm-pricing/sample and /api/mcp-servers/sample

The OpenAPI spec is at /openapi.json, and agents can discover the endpoints at /.well-known/x402 and /llms.txt.

To find other x402 APIs, browse the x402 section of Tools for Agents, a free directory that lists 2,393 x402 APIs from the public Bazaar index. If you want a cheat sheet of AI model prices and free tiers to go with it, the free PDF has 20 models on two pages.

If you want to be on the other side and sell an API this way, I also sell an x402 pay-per-call starter for Cloudflare ($19, paid). It is the code behind the API above.

Pay-per-call endpoints for AI agents: model prices, MCP servers, holidays, page checks (x402, USDC on Base)

FreeTier — Fri, 23 Oct 2026 09:05:01 +0000

Disclosure: I built this with help from AI tools, and it is my own paid service. Prices and limits below are what the API charges today.

I run a small pay-per-call API for AI agents: FreeTier Agent API. There's no signup and no API key. Your agent calls an endpoint, gets HTTP 402 with x402 payment requirements, pays a few cents in USDC on Base, and gets JSON. If the request fails on my side, the payment isn't settled.

This week I added 19 endpoints. Each one is built on data that may legally be reused, and every response has a sources field so the agent can see where the answer came from.

Endpoint	Price	What it returns
`/api/llm-pricing`	$0.001	List prices for ~3,000 models (per 1M input/output/cached tokens, context window, vision/tools flags), plus verified free tiers
`/api/llm-cost`	$0.001	Cost of one job across up to 15 models; tokens from counts or estimated from text
`/api/mcp-servers`	$0.001	Search 4,259 MCP servers by keyword, category, language, OS, official flag
`/api/page-check`	$0.001	Status, title, meta, canonical, plus an "agent-friendliness" score (llms.txt, sitemap, JSON-LD, AI-crawler rules in robots.txt)
`/api/link-check`	$0.001	Status and redirects for up to 20 URLs
`/api/page-markdown`	$0.001	Page → clean Markdown (respects robots.txt)
`/api/country`	$0.001	ISO codes, currency, languages, time zones, current local time
`/api/holidays`	$0.001	Public holidays 2026-2027 by country, or "is this date a holiday?"
`/api/currency`	$0.001	ECB daily reference rates (~30 currencies), any pair between them
`/api/base-gas`	$0.001	Current Base gas price and block, from public RPCs
`/api/email-verify`	$0.001	Syntax, MX/DNS, disposable-domain and role-address flags. No SMTP probing, nothing stored
`/api/extract-json`	$0.001	Messy text + JSON Schema in, typed JSON out (small LLM on Workers AI, heuristic fallback)
`/api/x402-services`, `/api/agent-tools`	$0.001	Search ~8,900 x402 APIs and 4,259 MCP servers
`/api/dump/*`	$5-$9	Full JSON dumps: MCP directory, model pricing, world reference

Free, no payment needed: /api/mcp-servers/sample, /api/llm-pricing/sample, /api/x402-services/sample, /openapi.json, /llms.txt, /.well-known/x402. There is also a remote MCP server at /mcp (listed in the official MCP Registry). Its paid tools return the x402 payment details.

Where the data comes from

Model prices: BerriAI/litellm price table (MIT). These are list prices, so check the provider's page before you commit real spend.
MCP servers: punkpeye/awesome-mcp-servers (MIT).
Countries and time zones: GeoNames (CC BY 4.0).
Holidays: python-holidays (MIT). Lunar and decree-based dates can move.
Currency: the European Central Bank daily reference rates.
x402 service list: nohumans.directory (CC BY 4.0).
Disposable email domains: disposable-email-domains (CC0).
The page tools only fetch public URLs and send an identifying User-Agent. /api/page-markdown also refuses pages that robots.txt disallows.

No personal data anywhere.

Try it

curl -i "https://freetier-agent-api.pages.dev/api/llm-cost?models=gpt-4o-mini,claude-sonnet-4-5&input_tokens=1000&output_tokens=500&calls=1000"
# -> 402 + PAYMENT-REQUIRED header; pay with any x402 client (@x402/fetch, x402 for Python)

It runs on Cloudflare Pages' free plan, with the data bundled into the worker. Settlement goes through public facilitators, so there are no keys on my side. The endpoints are listed on x402scan, x402dash, 402index and nohumans.directory.

What would you want an agent to be able to buy for a cent? Tell me in the comments. I only add data I can cite.

Want every kit? The All-Access Bundle has 147 kits for $39 (card/PayPal guest checkout).

I let AI agents pay my API per call in USDC (x402 on Cloudflare's free plan, zero dependencies)

FreeTier — Mon, 19 Oct 2026 09:07:09 +0000

Disclosure: this post was written with AI assistance and reviewed before publishing. I sell a starter kit based on this code (link at the end); everything below works without buying it.

HTTP has had a status code for this since 1997: 402 Payment Required. With the x402 protocol it finally does something. An AI agent calls your endpoint, gets a 402 with machine-readable payment terms, signs a USDC authorization and retries. Then it gets the data. There's no signup, no API key and no Stripe account.

I wanted to know how little it takes, so I shipped a real one: freetier-agent-api.pages.dev. It's one _worker.js on Cloudflare Pages (free plan) with no npm dependencies.

The flow

GET /api/apis/search?q=weather with no payment returns 402. The response carries a base64 PAYMENT-REQUIRED header (x402 v2) and a JSON body (x402 v1, for older clients). Both say: pay 5000 atomic units of USDC (= $0.005) on Base to this address.
The client signs an EIP-3009 transferWithAuthorization and retries with a PAYMENT-SIGNATURE header.
The worker POSTs that payload to a facilitator /verify, runs the handler, then calls /settle. The facilitator broadcasts the transfer and pays the gas, and the USDC lands in my wallet.

The part that surprised me: you don't need API keys

Coinbase's facilitator needs CDP keys on mainnet. Several public facilitators don't: PayAI (facilitator.payai.network) and xpay (facilitator.xpay.sh) both settle Base mainnet USDC without auth. I use PayAI and fall back to xpay:

const FACILITATORS = ['https://facilitator.payai.network', 'https://facilitator.xpay.sh'];
async function fac(op, body) {
  for (const f of FACILITATORS) {
    try {
      const r = await fetch(`${f}/${op}`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
      const j = await r.json();
      if ('isValid' in j || 'success' in j) return j;
    } catch {}
  }
  return { error: 'no facilitator' };
}

Charge only after you succeed

Verify, run, settle, in that order. If the handler fails (bad URL, missing parameter), return 400 and never call settle, so the agent pays nothing. This matters, because agents retry a lot.

Testing without spending money

I generated a brand-new empty wallet with viem, signed a correct authorization and sent it to the live API. The facilitator answered invalid_exact_evm_insufficient_balance. So the signature, EIP-712 domain (USD Coin, version 2, chain 8453), amount and recipient were all accepted, and the only thing missing was money. That's a nice zero-cost end-to-end check.

Getting found by agents

A paid API nobody can find earns nothing. What worked:

Bazaar metadata in the 402 (extensions.bazaar with input/output JSON schemas)
/openapi.json with x-payment-info on each paid operation, plus /.well-known/x402
x402dash: one POST https://api.x402dash.com/v1/register {"url": ...} per endpoint. It probes the 402 live
x402scan: registration needs a Sign-In-With-X signature from any wallet, which @x402/extensions handles

What the API sells

/api/apis/search ($0.001): 2,230 link-checked public and free-tier APIs, with filters like auth=none&alive=yes
/api/free-tiers ($0.001): current free-tier limits for dev services and LLM APIs
/api/robots-check ($0.001): may user-agent X crawl this URL?
/api/page-meta ($0.001): title/OG/headings of a public page (respects robots.txt)

Free: /api/apis/sample, /openapi.json, /health.

Takeaways

x402 runs fine on a free edge runtime. You don't need a server, a database or any keys.
Return both v1 and v2 challenge formats for now; clients in the wild use both.
Discovery is the real work. List everywhere.

If you want the cleaned-up code with tests and the listing steps, it's in the x402 Pay-Per-Call Starter. Or just read the 402 response from the live API and build your own.

847 free APIs that need no API key (all link-checked in October 2026)

FreeTier — Sun, 18 Oct 2026 18:02:49 +0000

Disclosure: this post was written with AI assistance and reviewed before publishing. The full dataset is a paid download (link at the end); the list below is free.

Most "free API" lists are years old, and half the links are dead. I took the open-source public-apis list (MIT), added developer and AI free tiers, and checked every documentation URL on 17 October 2026.

Out of 2,230 APIs, 1,944 answered. 847 are live, served over HTTPS, and need no API key at all, which makes them perfect for prototypes, hackathons, bots and AI agents.

Here are 25 well-known ones from that no-key list:

Weather, earth & science

Open-Meteo: weather forecasts, free for non-commercial use
USGS Earthquake Hazards: real-time earthquake data
Sunrise and Sunset: times for any latitude/longitude
UK Carbon Intensity: Great Britain grid carbon intensity
GBIF: global biodiversity records
iNaturalist: citizen-science wildlife observations
arXiv: research paper metadata

Places & calendars

REST Countries: country facts
Nominatim: forward/reverse geocoding (read the usage policy)
Postcodes.io: UK postcode lookup
Nager.Date: public holidays for 90+ countries

Money & data

Frankfurter: exchange rates and time series
World Bank: world development indicators
Open Food Facts: food products database
Universities List: university names and domains

Words, books & culture

Free Dictionary: definitions, phonetics, synonyms
Datamuse: word-finding engine (rhymes, "means like")
Open Library: books and covers
Crossref: article and book metadata
Art Institute of Chicago: artworks and images
Wikipedia / MediaWiki: the encyclopedia

Fun & dev testing

PokéAPI: Pokémon data
Open Trivia DB: trivia questions
Spaceflight News: spaceflight news
JSONPlaceholder: fake REST API for testing

"No key" doesn't mean "no rules". Read each provider's terms, set a real User-Agent and cache responses.

How I checked them

One GET per URL, a 12-second timeout and an identifying User-Agent, with a second, slower pass for the failures. A 2xx/3xx counts as alive, and so does a 401/403/429, because those mean the server is up but blocks anonymous bots. It's a docs-page check, not an uptime guarantee.

Get the full list

The complete dataset has all 2,230 rows as CSV, JSON and SQLite. That includes the 847-row no-key file, 59 dev and AI free tiers with limits (Groq, Gemini, Mistral, Cloudflare Workers AI, Supabase, Neon and more), and the build script. It's the Verified API Directory 2026 for $12.

AI agents can query it per call instead, over x402 with USDC on Base, at freetier-agent-api.pages.dev.

Why You Should Keep a Decision Log (and a Simple Format to Start With)

FreeTier — Sat, 17 Oct 2026 16:07:15 +0000

Disclosure: this post was written with AI assistance and reviewed before publishing.

Six months after an important decision, most teams can tell you what they decided but not why. The context — the options considered, the constraints at the time, the assumptions — disappears. A decision log is a lightweight way to keep it. It's useful for teams and solo founders alike, and it takes a couple of minutes per decision.

What a decision log gives you

Memory. New team members can understand why things are the way they are.
Fewer repeated debates. When someone asks "why don't we just…?", you can point to the entry, and reopen it only if something has changed.
Better judgement over time. Reviewing past decisions against outcomes shows where your reasoning tends to be good or weak. A good decision can still have a bad outcome due to luck; the log helps you tell the difference.
Accountability without blame. It's clear who decided and on what basis.

Software teams have long done a version of this with Architecture Decision Records (ADRs). The same idea works for product, marketing, hiring and finance decisions.

What deserves an entry

Log decisions that are:

Hard to reverse (pricing changes, contracts, hiring, technology choices)
Expensive in money or time
Likely to be questioned later
Made under uncertainty, where you want to check your assumptions afterwards

Don't log everything. If an entry would take longer than the decision itself, skip it.

A simple format

ID: D-014
Date: 2026-10-14
Decision: Move from monthly to annual-only pricing for the Pro plan
Status: Accepted   (Proposed / Accepted / Superseded by D-0xx / Reversed)
Decider: Maria (with input from Jon, Priya)

Context:
  Churn on monthly Pro is high; support load from billing issues is growing.

Options considered:
  1. Keep monthly + annual
  2. Annual only, with a discount
  3. Monthly only, with a price increase

Reasoning:
  Option 2 reduces billing churn and support load; risk is lower conversion.

Assumptions:
  - Conversion drops by no more than 20%
  - Support tickets about billing fall noticeably

Review date: 2027-01-15
Outcome (filled in at review):

The assumptions and review date are what make the log more than a diary. They turn each decision into a small, checkable prediction.

Where to keep it

Anywhere searchable and shared:

A spreadsheet with one row per decision
A Notion or similar database with properties for status, decider, area and review date, plus a page body for the full reasoning
Markdown files in a repository for technical teams (the ADR approach)

The tool matters less than having one agreed location. Link to the entry from wherever the decision was discussed (meeting notes, tickets, chat).

Building the habit

Make it part of the decision meeting. The last item: "Who's writing the log entry?"
Keep entries short. Ten lines is plenty for most decisions.
Write it when you decide, not weeks later; context fades quickly.
Use a template so nobody starts from blank.

Reviewing decisions

Set a recurring reminder — monthly or quarterly — to look at entries whose review date has passed. For each:

What actually happened?
Were the assumptions right?
Was the reasoning sound given what we knew then?
Would we decide the same way again?

Record the outcome in the entry. If the decision changes, don't edit the original: create a new entry and mark the old one as superseded. That preserves the history.

Common mistakes

Logging only the decision, not the options and reasoning
No review date, so nothing is ever checked
Editing old entries instead of superseding them
Storing the log somewhere nobody looks
Logging trivial decisions until the habit becomes a chore

Summary

Record important, hard-to-reverse decisions in a short, consistent format that includes context, options, reasoning, assumptions and a review date. Keep it in one searchable place, write entries at decision time, and review them against outcomes. A few minutes per decision builds a memory your team can actually use.

If you'd rather start from a ready-made structure, I put together a small, inexpensive, AI-assisted kit on this topic: Decision log systems. There's a *free sample** (the intro plus one complete template), so you can check whether it's useful before paying anything. Everything above works without it. Other kits: all products.*

Want the related kits together? The Productivity & Focus Bundle has this kit plus 9 others for $15, or get all 147 kits in the All-Access Bundle for $39 (card/PayPal guest checkout).

Meeting Agendas That End on Time: A Practical Template and Rules

FreeTier — Sat, 17 Oct 2026 16:06:25 +0000

Disclosure: this post was written with AI assistance and reviewed before publishing.

Most bad meetings share a cause: nobody decided in advance what the meeting was for. A good agenda fixes that. It forces the organiser to state the purpose, lets people prepare, and gives everyone permission to stop when the work is done. Here's a template and a set of rules you can start using this week.

First question: does this need a meeting?

Before writing an agenda, check whether the goal could be reached another way:

Sharing information only? A written update or short recorded video is often enough.
Collecting input? A shared document with comments may work better and include quieter people.
Making a decision, solving a problem or resolving a disagreement? These usually benefit from a live conversation.

If it's the third kind, write an agenda.

The agenda template

Meeting: [Name]
Date / time / length: [e.g. Tue 10:00, 30 min]
Purpose: [One sentence: what will be different after this meeting?]
Desired outcome: [Decision made / plan agreed / list of options]
Attendees: [Name – role in this meeting]
Pre-read: [Links, and what to read before]

Agenda
1. [Topic] – [Owner] – [Minutes] – [Type: inform / discuss / decide]
2. ...
3. Recap: decisions, action items, owners, deadlines – 5 min

The type label for each item is the most useful part. "Decide" items need a proposal and a decision-maker; "discuss" items need a time box; "inform" items might belong in the pre-read instead.

Rules for writing the agenda

Write the purpose as an outcome. "Agree the Q1 launch date" is better than "Q1 launch".
Put decisions first. Energy and attention are highest at the start.
Time-box every item, and make the sum shorter than the meeting so there's buffer.
Assign an owner per item — the person who presents and drives it.
Phrase items as questions: "Should we move the launch to March?" focuses discussion better than a topic name.
Send it at least a day in advance for recurring meetings, earlier for important ones.
Invite only people with a role. Others can read the notes.

Running the meeting

Start on time, even if someone is late. Waiting rewards lateness.
Restate the purpose in the first minute.
Use a timekeeper — someone other than the facilitator if possible.
Park off-topic items in a visible "parking lot" list instead of debating them.
Close each "decide" item explicitly: "So we're deciding X. Any objections?" Then write it down.

The last five minutes matter most

Reserve time for a recap:

Decisions made (and who made them)
Action items, each with one owner and a deadline
Open questions and where they'll be handled

An action item without an owner usually doesn't happen. "We'll look into it" isn't an action item; "Sam drafts the pricing options by Friday" is.

After the meeting

Send short notes within a few hours, in the same place each time (the meeting invite, a shared document or the team channel). Notes should fit on one screen: decisions, actions, owners, deadlines, and links. Long transcripts are rarely read; if you record meetings or use automatic transcription, still write the short summary.

Recurring meetings

Recurring meetings drift. Every couple of months, ask:

Is this meeting still needed?
Could it be shorter or less frequent?
Are the right people attending?
Are we using the agenda, or just talking?

Defaulting to 25 or 50 minutes instead of 30 or 60 gives people a break between back-to-back meetings; many calendar tools have a setting for this.

Example: a 30-minute decision meeting

Purpose: Decide whether to switch our support tool before January.
1. Recap of the two options (pre-read) – Ana – 5 min – inform
2. Questions and concerns – all – 10 min – discuss
3. Decision: switch now, switch later, or stay – Lee (decides) – 10 min – decide
4. Recap: actions and owners – 5 min

Common mistakes

No stated purpose
Agendas that are just topic names
Too many items for the time available
No decision-maker named for "decide" items
No written follow-up

Summary

Check whether you need a meeting, write the purpose as an outcome, label every item inform/discuss/decide, time-box and assign owners, close decisions explicitly, keep five minutes for a recap and send short notes the same day. The agenda is what lets a meeting end early.

If you'd rather start from a ready-made structure, I put together a small, inexpensive, AI-assisted kit on this topic: Meeting agenda templates. There's a *free sample** (the intro plus one complete template), so you can check whether it's useful before paying anything. Everything above works without it. Other kits: all products.*

Want the related kits together? The Productivity & Focus Bundle has this kit plus 9 others for $15, or get all 147 kits in the All-Access Bundle for $39 (card/PayPal guest checkout).

How to Schedule Deep Work When Your Calendar Is Already Full

FreeTier — Sat, 17 Oct 2026 12:03:28 +0000

Disclosure: this post was written with AI assistance and reviewed before publishing.

"Deep work" — a term popularised by Cal Newport — means focused, uninterrupted effort on cognitively demanding tasks: writing, designing, analysing, coding, strategic thinking. Most people agree it matters. The trouble is that calendars fill up with meetings and messages, and deep work gets whatever scraps are left. Here's a practical way to protect time for it, even in a busy week.

Step 1: Know what your deep work actually is

List the three to five tasks in your role that create the most value and need sustained concentration. Be concrete: "write the quarterly report", "design the onboarding flow", "draft chapter 4". If you can't name them, focus sessions turn into inbox time.

Step 2: Find your best hours

Most people have a few hours a day when concentration comes more easily. For many it's the morning, but not for everyone. For one week, note when focused work felt easiest and when it felt like pushing through mud. Use those hours for deep work and move meetings and admin elsewhere where you can.

Step 3: Block time like a meeting

Put deep work in your calendar as real events:

Length: 60–120 minutes is a practical range for most people; start with 60 if you're not used to it.
Frequency: even three blocks a week is a meaningful change if you currently have none.
Name: use the actual task ("Draft report section 2"), not "Focus".
Visibility: mark yourself busy. If your team uses shared calendars, explain what the blocks are.

Some people prefer a fixed daily rhythm (e.g. 8:30–10:30 every day); others plan blocks weekly around meetings. Both work. The fixed rhythm requires fewer decisions.

Step 4: Protect the block

Interruptions are the main enemy. Before each session:

Close email and chat, or set status to "Do not disturb".
Silence phone notifications or put the phone in another room.
Open only the files and tabs needed for the task.
Write a one-line goal for the session: "Finish outline and first 500 words."
Keep a notepad for stray thoughts ("reply to Tom") so you can capture and return.

If your role requires being reachable, agree a backup channel for real emergencies, so you don't need to check everything.

Step 5: Shape the rest of your day

Deep work is easier when shallow work has a place too:

Batch messages: check email and chat at set times (e.g. late morning and mid-afternoon).
Cluster meetings on certain days or half-days, leaving other days lighter.
Shut down deliberately: end the day by noting where you stopped and the first step for tomorrow. Starting is the hardest part of a deep work session; a clear first step helps.

Step 6: Track and adjust

Keep a simple count of deep work hours per week. A spreadsheet or a tally on paper works:

Week | Planned blocks | Completed | Hours | Main output
41   |       5        |     3     |  4.5  | report draft
42   |       5        |     4     |  6.0  | report final

Each week, ask what broke the blocks that didn't happen — a recurring meeting, messages, low energy — and fix one thing.

When your job is mostly reactive

Some roles (support, operations, management) are reactive by design. Deep work still helps, but in smaller doses:

Negotiate one or two protected blocks per week with your manager or team.
Use shorter sessions (45 minutes) more often.
Trade coverage with a colleague so each of you gets focus time.

Common mistakes

Scheduling blocks without a defined task
Choosing hours when your energy is lowest
Letting "just one quick message" break the session
Planning five hours a day immediately and burning out
Never reviewing what stops blocks from happening

Summary

Name your high-value tasks, find your best hours, block them in the calendar with specific goals, remove interruptions during the session, batch shallow work around it and track hours weekly. Start with a few protected blocks and grow from there.

If you'd rather start from a ready-made structure, I put together a small, inexpensive, AI-assisted kit on this topic: Deep work protocols. There's a *free sample** (the intro plus one complete template), so you can check whether it's useful before paying anything. Everything above works without it. Other kits: all products.*

Want the related kits together? The Productivity & Focus Bundle has this kit plus 9 others for $15, or get all 147 kits in the All-Access Bundle for $39 (card/PayPal guest checkout).

Sales Scripts That Don't Sound Scripted: A Framework for Discovery Calls

FreeTier — Sat, 17 Oct 2026 12:02:52 +0000

Disclosure: this post was written with AI assistance and reviewed before publishing.

"Script" has a bad reputation, because most people picture someone reading a wall of text at a stranger. A good sales script is closer to a pilot's checklist: a structure that makes sure you cover what matters, while leaving room for an actual conversation. This is a framework for discovery calls — the first real conversation with a potential customer — that works for freelancers, agencies and small B2B teams.

The goal of a discovery call

You are not trying to close on the first call. You're trying to find out three things:

Is there a real problem that matters enough to spend money on?
Can you solve it better than the alternatives (including doing nothing)?
Is there a path to a decision — budget, timing, the right people?

If any answer is no, the best outcome is a polite, quick exit. That saves both sides time.

The five-part structure

1. Opening (1–2 minutes)

Set the agenda and get permission:

"Thanks for making time. I'd suggest we spend most of this call on what you're trying to achieve, then I'll share how I usually help, and at the end we can decide together whether a next step makes sense. Does that work?"

This lowers pressure, and it makes ending without a sale feel normal.

2. Situation (5 minutes)

Understand the context with open questions:

"Can you walk me through how you handle this today?"
"Who's involved in that process?"
"What tools are you using?"

Keep these brief. Too many situation questions feel like an interrogation.

3. Problem and impact (10 minutes)

This is the core. Dig into what's not working and why it matters:

"What's the most frustrating part of that?"
"How often does that happen?"
"What does it cost you — in time, money or missed opportunities?"
"What have you tried already?"
"What happens if nothing changes in the next six months?"

Then summarise back in their words: "So if I've got it right, the main issue is X, it happens about Y, and it's costing roughly Z. Is that fair?" Summarising is the single most underused technique in sales.

4. Fit (5 minutes)

Only now describe your solution, and only the parts that address what you just heard. Short examples beat feature lists: "A client with a similar setup reduced that from two days to half a day by…" Avoid claims you can't back up.

5. Next step (2–3 minutes)

Be explicit:

"Based on what you've said, I think a proposal for A and B makes sense. Would it be useful if I sent that by Thursday, and we booked 20 minutes on Monday to go through it?"

Get a date in the calendar before you hang up. "I'll think about it" with no date usually means the deal fades.

Handling common objections

"It's too expensive." Ask: "Compared to what?" Then revisit the cost of the problem they described. Sometimes the honest answer is a smaller scope.
"We need to think about it." Ask: "Of course — what specifically would you want to think through?" This often surfaces the real concern.
"Send me some information." Ask what they'd look for in it, so you send something relevant, and agree on when to talk again.
"We're working with someone else." Ask what's working well with them. If it's going well, respect that and leave the door open.

Making it sound natural

Write prompts, not paragraphs. Bullet points you glance at, not lines you read.
Practise out loud a few times until the questions feel like yours.
Listen more than you talk; a common rule of thumb is that the prospect should speak most of the time.
Take notes in the prospect's words; you'll reuse them in the proposal.

Summary

Open with an agenda, keep situation questions short, spend most of the call on problems and their impact, summarise back, present only the relevant parts of your offer, and leave with a concrete next step in the calendar. Structure is what lets you sound relaxed.

If you'd rather start from a ready-made structure, I put together a small, inexpensive, AI-assisted kit on this topic: Sales script packs. There's a *free sample** (the intro plus one complete template), so you can check whether it's useful before paying anything. Everything above works without it. Other kits: all products.*

Want the related kits together? The Freelancer Business Bundle has this kit plus 7 others for $15, or get all 147 kits in the All-Access Bundle for $39 (card/PayPal guest checkout).

Which Workflows Should You Automate First? A Blueprint for Small Teams

FreeTier — Sat, 17 Oct 2026 08:17:14 +0000

Disclosure: this post was written with AI assistance and reviewed before publishing.

Automation tools like Zapier, Make, n8n and Power Automate make it easy to connect apps. The hard part isn't building a workflow — it's choosing the right ones, and building them so they don't silently break. Here's a blueprint for picking, designing and maintaining automations in a small business or team.

Step 1: Inventory your repetitive work

For one or two weeks, keep a simple log of tasks that feel repetitive. For each, note:

What triggers it (a form, an email, a payment, a date)
What you do (copy data, send a message, create a file)
How often it happens
How long it takes
What goes wrong when it's done badly

You'll usually end up with 10–30 candidates.

Step 2: Score and choose

Score each candidate from 1–5 on:

Frequency × time — how many minutes per month it costs
Error cost — what a mistake costs
Stability — does the process stay the same, or change every month?
Simplicity — how many apps and decisions are involved?

Automate first what is frequent, stable and simple. Leave processes that change often, or that need judgement, for later — or keep them manual. Automating a messy process just makes the mess faster.

Step 3: Map before you build

Draw the workflow as a sequence before touching any tool:

Trigger: New paid order in shop
  → Step 1: Add customer to spreadsheet (Orders tab)
  → Step 2: Send welcome email with download link
  → Step 3: If order > $100 → notify owner in chat
  → Step 4: Create follow-up task in 7 days
Failure: if step 2 fails → email owner

Mapping reveals missing data (do you actually have the customer's name?), decision points and the things that can fail.

Step 4: Build with reliability in mind

A few habits prevent most automation headaches:

Use stable identifiers. Match records by an ID or email, not by name.
Add error notifications. Most platforms can alert you when a run fails; turn it on.
Avoid loops. A workflow that updates a record that triggers the same workflow can run forever and use up your plan's task quota.
Test with real but harmless data. Use your own email or a test record.
Keep secrets in the tool's credential store, not pasted into steps.
Name things clearly. "Shop → Sheet → Welcome email (v2)" beats "My Zap 7".

Step 5: Document every automation

Keep a simple register — a spreadsheet or a database with one row per automation:

Name	Trigger	Apps	Owner	Last checked	What breaks if it stops

The last column matters most. When something stops working, you need to know immediately what's affected.

Step 6: Monitor and review

Automations decay when apps change their fields or APIs, or when a connected account's password changes. Schedule a monthly 15-minute check:

Review failed runs
Confirm key automations ran as expected
Check your plan's usage limits
Retire workflows nobody needs any more

Common first automations

These are often good starting points because they're frequent and simple:

Form submissions → spreadsheet or CRM + confirmation email
New invoice paid → thank-you email + update records
New calendar booking → prep document created from a template
New file in a folder → notify the team
Weekly scheduled report compiled from a spreadsheet

Choosing a tool

Zapier: easiest to start, large app library, gets expensive at volume.
Make: visual, flexible, generally cheaper per operation, steeper learning curve.
n8n: open source and self-hostable, good if you're technical and want control.
Power Automate: natural fit if your business runs on Microsoft 365.

Pricing and limits change regularly, so check current plans before committing.

Summary

Log repetitive work, score candidates on frequency, error cost, stability and simplicity, map each workflow before building it, add error alerts, document every automation in a register and review monthly. Fewer, reliable automations beat many fragile ones.

If you'd rather start from a ready-made structure, I put together a small, inexpensive, AI-assisted kit on this topic: Workflow automation blueprints. There's a *free sample** (the intro plus one complete template), so you can check whether it's useful before paying anything. Everything above works without it. Other kits: all products.*

Want every kit? The All-Access Bundle has 147 kits for $39 (card/PayPal guest checkout).