canonical: https://jentic.com/apis/result.dev/result

# Result API

The Result API runs the signup side of Result, a workspace for running a business: it reports where an account is in signing up, fills a profile's name and photo from a Google ID token, checks whether an @handle is free, creates a business and claims its permanent handle, and mints a one-time code to carry a session from result.dev into the product at app.result.dev. Every operation takes the bearer refresh token of a signed-in Result session, and there is no machine-to-machine tier. Operating a Result business itself, such as its numbers, pipeline, and publishing, sits outside this API.

## For AI agents

Read a Result account's signup state, check @handle availability, create a business with its permanent handle, and mint a one-time session handoff code, using a signed-in session's bearer token.

## Scope

Does not handle operating a business, such as reading its numbers, working its pipeline, publishing, or answering support, and does not take payments. Use for Result account signup, handle checks, business creation, and session handoff only.

## Capabilities

- Read where an account is in signing up, including entitled, provisioned, and businessId, with GET `/api/account/state`
- Check whether an @handle is free with GET `/api/username/check` before claiming it
- Create a business and claim its permanent public @handle with POST `/api/business`, which spends nothing
- Fill a profile's display name and avatar from a Google ID token with POST `/api/account/identity`, without overwriting names set in Settings
- Mint a single-use code that carries the session from result.dev to app.result.dev with POST `/api/auth/handoff`

## Use cases

### Agent-assisted business setup through Jentic

A developer setting up a Result business asks their agent, connected through Jentic, to check a handle and create the business. The agent searches by intent, gets checkUsernameAvailability and createBusiness with their schemas, confirms the handle is free, and creates the business with a name, username, and description. Creating a business spends nothing, since paid setup is released later by the plan.

Example prompt: Call GET `/api/username/check` with username 'acmebakery'; if it is free, call POST `/api/business` with name 'Acme Bakery', username 'acmebakery', and description 'Sourdough delivery in Cork'

### Signup progress check

Before suggesting a next step, an agent reads GET `/api/account/state` to learn whether the account is entitled to a live plan, whether paid setup is provisioned, whether a businessId exists yet, and how far the signup answers go. It can then tell the user whether they are waiting on payment or on setup.

Example prompt: Call GET `/api/account/state` and report entitled, provisioned, businessId, and the answers.kind value

### Session handoff to the Result app

The refresh token on result.dev is host-only, so moving into app.result.dev uses a one-time code instead of a shared cookie. POST `/api/auth/handoff` returns a single-use code that expires in minutes, which the product's `/auth/enter` page spends, optionally landing on a path given in next.

Example prompt: Call POST `/api/auth/handoff` with next '/settings' and return the code to pass to the product's `/auth/enter` page

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/api/account/state` | Read signup state |
| GET | `/api/username/check` | Check @handle availability |
| POST | `/api/business` | Create a business and claim its handle |
| POST | `/api/account/identity` | Fill name and photo from a Google ID token |
| POST | `/api/auth/handoff` | Mint a one-time handoff code |

## Key resources

- **Account state** — Signup progress: entitled, provisioned, named, businessId, and signup answers
- **Business** — A Result business and its permanent public @handle
- **Session handoff** — A single-use code for crossing from result.dev to app.result.dev

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 70 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 100 / 100
  - Developer Experience & Jentic Compatibility: 69 / 100
  - AI-Readiness & Agent Experience: 57 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 60 / 100
- **View full report:** https://jentic.com/apis/result.dev/result/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Result API by hand means carrying a signed-in session's bearer refresh token, since there is no client-secret flow, and handling the 409 and 201-versus-200 replies on business creation. Through Jentic you install once, import the Result API from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** The Result API carries its targets, such as the handle and business name, in the query string or request body, so rules bound which operations your agent may call, not which business. You choose the operations it may run, so claiming a permanent handle with createBusiness or minting a handoff code are not included unless you add them.
- **Credential handling:** Your Result session token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'check if a business handle is free' or 'create a business on Result', and Jentic returns the matching Result operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Clerk Backend API** — User, session, and organization management for your own app
- **Auth0 Management API** — Identity platform for users, connections, and sessions
- **Stripe API** — Payments and subscriptions

## FAQ

### What authentication does the Result API use?

Per its OpenAPI spec, every operation takes the refresh token of a signed-in Result session as a bearer token in the Authorization header. That token comes from signing in with Google on result.dev or app.result.dev, and the spec states there is no machine-to-machine tier or client-secret flow. Through Jentic the token is stored encrypted by your own Jentic One instance and injected at call time.

### Is there a Result MCP server?

Yes - Result runs an official MCP server at app.result.dev/mcp, authorised with OAuth 2.1 and PKCE, and its spec names that server as the way an agent operates a business. This HTTP API covers signup and setup. You can also connect it directly through Jentic: your agent gets the full 5-endpoint surface without loading another server's tool definitions into its context, and your rules decide which operations the agent may call.

### Can I check whether a Result handle is free before creating a business?

Yes. GET `/api/username/check` takes a required username query parameter and reports whether the handle is free. It is advisory, since handles are global and permanent and POST `/api/business` can still answer 409 with the username_taken code if someone claims it first.

### What are the rate limits for the Result API?

The OpenAPI spec does not specify rate limits. Check https://result.dev/contact, the support contact listed in the spec, for current limits.

### How do I create a Result business through Jentic?

Install Jentic One, add the Result API from the directory, and store your session token. Your agent searches for 'create a business on Result', gets POST `/api/business` with its schema, and calls it with the required name plus an optional username and description. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Can I limit what my agent is allowed to do with the Result API?

Yes. Write a rule that allows only GET `/api/account/state` and GET `/api/username/check`, so the agent can report signup progress and test handles but cannot claim a permanent handle or mint a handoff code, and every call it makes is logged.
