getlinkbunny.com

LinkBunny is a manually reviewed marketplace where site owners using Claude Code or Codex exchange nofollow backlinks. Every site profile is reviewed by a human before it can participate, and matching is based on Domain Rating (DR) plus contextual fit. Your coding agent requests one DR-matched link at a time, and you approve or reject each request. This fits site owners who already use Claude Code or Codex — the current pool is strongest for software, SaaS, developer tools, and related founder, creator, and marketing sites.

How site review works

Before any site can participate, its profile goes through manual review. The stated purpose is to reduce spam sites in the network. LinkBunny describes itself as a new, manually reviewed marketplace starting with a small founding group.

The practical implication: you can't just register and immediately start exchanging links. Your profile has to pass review first. The site notes that after joining, Boon (the operator) helps by email or DM with your first profile and coding-agent setup.

What you register

When you sign up, you add:

• One target URL
• The part of your site where your agent may add links

Both must use the same domain. This scopes where your agent is allowed to place links, so it can't touch parts of your site you haven't approved.

How matching works

Matching combines two factors:

The current pool reaches DR up to 61, per the site's launch description.

The request-and-approve loop

Your agent doesn't place links unilaterally. The workflow is:

1. Check in — Your agent receives a link request containing a target URL, requested anchor text, Domain Rating, and a seven-day deadline.
2. Review and place — Your agent looks for a suitable spot within the approved part of your site. You approve the nofollow link or reject the request.
3. Report — After the link is published, your agent tells LinkBunny where it was added.

You can loop or schedule your agent to ask LinkBunny for one DR-matched link request at a time. You approve the placement or reject anything that doesn't fit.

What this means for fit

LinkBunny fits site owners who already use Claude Code or Codex. The current pool is strongest for software, SaaS, developer tools, and related founder, creator, and marketing sites.

Because backlink opportunities depend on eligible matches in the network, participation doesn't guarantee a steady stream of requests — it depends on who else is in the pool and whether your site matches them.

Cost and plan scope

The founding plan is $20/month and covers up to 10 sites. There are no per-backlink fees. The site states that founders keep their founding price while subscribed, even as pricing for new customers changes.

Before subscribing, the site suggests asking Boon for a current-pool fit check — useful if you want to confirm your site matches the existing network before paying.

Common questions before joining

Does my site fit? Only if you already use Claude Code or Codex, and your site is in or adjacent to software, SaaS, developer tools, or founder/creator/marketing content.

What happens after signup? Subscribe, create an API token, connect your agent, and add your first site. Each profile is manually reviewed before it can participate.

Can I reject requests? Yes — you or your agent review each request and reject anything unsuitable.

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

• An operation list grouped by tag or path, with HTTP method and path.
• Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
• Request and response schemas rendered as expandable trees, including nested objects and arrays.
• Authentication details pulled from the securitySchemes section.
• Interactive request consoles that let a reader send a real call from the browser.
• Generated code samples in several languages, derived from the same schemas.
• Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

• Your API has more than a handful of endpoints, or changes frequently.
• You ship client SDKs or code samples in more than one language.
• Multiple teams consume the API and need a consistent, always-current reference.
• You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

• Your API is small and stable, and the reference fits on one page.
• Your documentation is mostly conceptual and contains little endpoint-level detail.
• You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

1. Produce one valid OpenAPI document for a single API version.
2. Add a linter with rules for descriptions, operation IDs, and error responses.
3. Wire the docs build into CI so a failing spec fails the build.
4. Render the reference and review it as a reader, not as the author.
5. Write the two or three conceptual pages the generator cannot produce.
6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.

A postal code API returns structured location data for a given ZIP Code or Canadian postal code. A typical response includes the code itself, city, state or province, county, latitude/longitude, and — where available — ZIP+4 detail. More complete services add time zone, area codes, boundary geometry, and demographic fields. You send a code (or an address), and the API sends back a machine-readable record you can store, validate, or display.

This article explains what those responses contain, how requests are usually shaped, and where postal code data fits into real applications.

First, clear up the word "code"

The keyword "code" is overloaded, and that causes real confusion for developers:

• Postal code — the ZIP Code (U.S.) or postal code (Canada) that identifies a delivery area.
• API key — the credential you use to authenticate your requests. It is not postal data.
• Source code — the program you write to call the API.

When someone searches for "postal code API code," they usually want example request/response code for a postal code service. The rest of this article treats it that way.

What a postal code API actually returns

Response fields vary by provider and endpoint, but the core set is fairly consistent. A single-code lookup commonly returns:

Richer datasets add 90+ fields: boundaries, population, income, elevation, and more. You rarely need all of them — request only what your application uses.

A representative JSON response

{
  "postal_code": "90210",
  "city": "Beverly Hills",
  "state": "CA",
  "county": "Los Angeles",
  "latitude": 34.0901,
  "longitude": -118.4065,
  "timezone": "America/Los_Angeles",
  "area_codes": ["310", "424"]
}

XML responses carry the same information in tag form. Choose based on what your stack parses most easily; JSON is the common default.

Common request patterns

Most postal code APIs support four patterns. Knowing which one you need prevents wasted calls.

1. Lookup by code

You have a code and want its details. This is the simplest and fastest call.

GET /lookup?code=90210

2. Reverse lookup by address

You have a street address and want to confirm or complete the code. This is the pattern behind checkout address validation.

GET /validate?street=...&city=...&state=...

3. Radius search

You have a center point and want all codes within a distance. Useful for store locators and delivery zones.

GET /radius?code=90210&miles=10

4. Batch validation

You have a file of addresses and want them cleaned in bulk. Batch endpoints trade latency for throughput and usually have their own limits.

Handling missing and ambiguous matches

Real data is messy. Plan for these cases:

• No match — the code doesn't exist or the address is malformed. Return a clear error rather than a silent empty object.
• Multiple matches — a city name may map to several codes, or a code may span several acceptable city names. Decide whether to pick the primary or return a list.
• Partial match — the street is valid but the ZIP+4 isn't. Fall back to the 5-digit code.
• Stale data — codes are added, retired, and reassigned. Refresh your dataset on a regular schedule.

A practical rule: validate at the point of entry, store the normalized result, and never re-derive it later from raw user input.

Practical use cases

• Checkout address validation — catch typos before shipping, reduce failed deliveries.
• Shipping zone lookup — map a code to a zone, carrier route, or rate table.
• Data enrichment — append county, coordinates, or demographics to existing records.
• Store and service locators — radius search to find nearby branches or coverage areas.
• Territory and tax logic — county and boundary data drive jurisdiction rules.

Licensing and data-source considerations

Postal code data originates with national authorities — USPS in the United States and Canada Post in Canada. Providers license and repackage it, which is why accuracy, update frequency, and field coverage differ between services. Before committing:

• Confirm the data source and how often it refreshes.
• Check whether ZIP+4 and boundary data are included or sold separately.
• Review usage limits and whether batch processing is allowed.
• Read the license terms for redistribution and storage.

Pricing and plan details change, so check the provider's current documentation rather than relying on secondhand figures.

Getting started

1. Decide which request pattern you need (lookup, reverse, radius, or batch).
2. Pick the fields you'll actually store.
3. Write a small test call and inspect the raw response.
4. Add error handling for no-match and ambiguous cases.
5. Cache results where the same codes repeat.

A postal code API is ultimately a translation layer: you give it a code or an address, and it gives back structured location facts. Understand the fields, match them to your use case, and handle the messy edges — that's most of the work.

LinkBunny is a manually reviewed marketplace where site owners use coding agents to exchange nofollow backlinks. To set it up, you sign up, register one target URL plus the part of your site where your agent may add links (both on the same domain), create an API token, and connect your agent with the provided setup prompt. From there your agent receives one DR-matched link request at a time, you approve or reject each placement, and after publishing the agent reports where the link was added. This fits site owners who already use Claude Code or Codex; the current pool is strongest for software, SaaS, developer tools, and related founder, creator, and marketing sites.

Before you start

Two things determine whether setup will work for you:

• You already use a coding agent. LinkBunny's workflow assumes Claude Code or Codex. If you don't use either, the agent-driven loop described below won't apply.
• You own the site you're registering. You add a target URL and the specific part of your site where the agent is allowed to place links. Both must use the same domain.

If you're unsure whether your site fits the current pool, the site suggests asking Boon for a fit check before subscribing.

Setup steps

1. Sign up and add your site profile

Create an account and add:

• One target URL
• The part of your site where your agent may add links

Both must share the same domain. Each profile is manually reviewed before it can participate, which the site describes as a measure to reduce spam sites.

2. Subscribe and create an API token

The founding plan is $20/month and covers up to 10 sites. There are no per-backlink fees. The site states that you keep your founding price while subscribed, even as pricing for new customers changes.

After subscribing, create an API token. This is what lets your coding agent talk to LinkBunny.

3. Connect your agent with the setup prompt

Paste the provided setup prompt into your coding agent. According to the site, it will guide you through:

• Account creation or sign-in
• Subscription
• API-token setup
• Adding your site profile

4. Let the agent check in

Once connected, your agent asks LinkBunny for one link request at a time. Each request includes:

5. Review, place, and report

Your agent looks for a suitable spot within the part of your site you designated. You then approve the nofollow link or reject the request. After the link is published, your agent tells LinkBunny where it was added.

What to expect in practice

• One request at a time. The loop is deliberately paced rather than bulk. You can loop or schedule your agent to keep asking for the next request.
• You stay in control. Nothing gets placed without your approval, and you can reject anything that doesn't fit.
• Opportunities depend on matches. Backlink opportunities depend on eligible matches in the network, so volume isn't guaranteed.
• Manual review at the front door. Every profile is reviewed before it can participate.

Common sticking points

• Domain mismatch. The target URL and the link-placement area must be on the same domain. If they aren't, the profile won't line up.
• No agent, no loop. The workflow is built around Claude Code or Codex. Without one, you'd be doing the check-in and placement work manually.
• Expecting guaranteed links. The site is explicit that opportunities depend on eligible matches. Subscribing doesn't buy a set number of backlinks.
• Skipping the fit check. If your site is outside software, SaaS, developer tools, or adjacent founder/creator/marketing territory, ask about the current pool before paying.

Cost summary

The site notes that after joining, Boon helps by email or DM with your first profile and coding-agent setup and check-in.

LinkBunny is a manually reviewed marketplace and API that lets site owners exchange nofollow backlinks through coding agents like Claude Code or Codex. You register a site you own, your agent asks LinkBunny for one Domain Rating-matched link request at a time, and you approve or reject each placement before anything goes live. It fits site owners who already work with a coding agent and run software, SaaS, developer tool, or related founder, creator, and marketing sites.

How the exchange works

The core loop is a three-step handoff between you, your agent, and the marketplace:

1. Sign up. Add one target URL and the part of your site where your agent is allowed to add links. Both must use the same domain.
2. Check in. Your agent receives a link request containing a target URL, a requested anchor, the Domain Rating, and a seven-day deadline.
3. Review, place, and report. Your agent looks for a suitable spot within the permitted part of your site. You approve the nofollow link or reject the request. Once published, your agent tells LinkBunny where the link was added.

The key constraint is that requests arrive one at a time and are DR-matched, so your agent isn't asked to place a batch of unrelated links. You stay in the approval path — nothing is published without your sign-off.

What makes it different from a typical link marketplace

The "no per-backlink fees" detail matters if you're comparing against marketplaces that charge per placement — here the cost is a flat subscription, and backlink opportunities depend on eligible matches in the network.

Who it's for

LinkBunny is aimed at site owners who already use Claude Code or Codex. The current pool is described as strongest for software, SaaS, developer tools, and related founder, creator, and marketing sites. If your site sits outside those categories, the available matches may be thin.

Cost and setup

The founding plan is $20/month for up to 10 sites, with no per-backlink charges. The site states that founders keep this price while subscribed, even as pricing for new customers changes. Setup flow: subscribe, create an API token, connect your agent, and add your first site profile.

The site also notes that "Boon" can help by email or DM with your first profile and coding-agent setup, and offers a current-pool fit check before you subscribe — useful if you want to confirm matches exist for your niche before paying.

Practical caveats

• Match availability is not guaranteed. Backlink opportunities depend on eligible matches in the network, which is described as a small founding group at launch.
• Manual review adds a gate. Your profile must pass review before participating, so signup isn't instant access.
• You still do the judgment call. The agent finds a spot and reports back, but approval is yours — treat the agent as a placement assistant, not an autopilot.

If you want to check whether your site fits the current pool before committing, the fit-check offer is the lowest-risk first step.