> ## Documentation Index
> Fetch the complete documentation index at: https://docs.stophy.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Collect the key

> Collect the key once your person approves. Send one request and get JSON back. Examples in cURL, TypeScript and Python. A failed call costs nothing.

> [!NOTE]
>
> Needs no API key.

Free, and needs no key. Answers 202 with status waiting until your person approves, so poll every few seconds. After approval it answers 200 with the key exactly once. A code that is unknown, expired or already collected is notFound: sign up again.

```bash cURL theme={null}
curl -X POST https://api.stophy.dev/v1/signup/poll \
  -H "Content-Type: application/json" \
  -d '{"code":"<code>"}'
```

```typescript TypeScript theme={null}
const response = await fetch("https://api.stophy.dev/v1/signup/poll", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ code: "<code>" }),
});
console.log(await response.json());
```

```python Python theme={null}
import requests

response = requests.post(
    "https://api.stophy.dev/v1/signup/poll",
    json={"code": "<code>"},
)
print(response.json())
```

```json 202 theme={null}
{
  "success": true,
  "data": {
    "status": "waiting",
    "claimUrl": "<claimUrl>"
  },
  "creditsUsed": 0,
  "requestId": "f178fb12-7986-4688-a700-915024faa1b9"
}
```


## OpenAPI

````yaml api-reference/openapi.json POST /v1/signup/poll
openapi: 3.1.0
info:
  title: Stophy API
  version: '1'
  description: >-
    Every endpoint is a POST that takes its input as a JSON object body. Unknown
    fields are rejected with 400.


    Responses leave out empty values: null, empty strings, empty objects and
    empty nested lists are not sent.


    Text comes back whole. To get shorter responses, add
    ?maxTextLength=<characters> to the URL. Every text value longer than that is
    cut and ends with …. A screenshot is never cut, and a page whose text was
    cut has isTruncated set to true.


    x-credits is what one call costs. Every call costs the same, whatever it
    returns, unless an operation's description says it costs per 10 results, or
    per second of audio. Then x-credits is the lowest price and x-credits-max
    the most one call can cost. Where an operation takes limit, send it to
    return fewer results and pay for fewer.


    When a response has a cursor, send it back unchanged with the same input to
    get the next page. When it has a page, send the next page number.
servers:
  - url: https://api.stophy.dev
security:
  - apiKey: []
paths:
  /v1/signup/poll:
    post:
      summary: Collect the key once your person approves.
      description: >-
        Free, and needs no key. Answers 202 with status waiting until your
        person approves, so poll every few seconds. After approval it answers
        200 with the key exactly once. A code that is unknown, expired or
        already collected is notFound: sign up again.
      operationId: pollSignUp
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - code
              properties:
                code:
                  type: string
      responses:
        '200':
          description: Your key. Shown once.
          headers:
            X-Request-ID:
              $ref: '#/components/headers/RequestId'
          content:
            application/json:
              schema:
                type: object
                required:
                  - success
                  - data
                  - creditsUsed
                  - requestId
                properties:
                  success:
                    const: true
                  data:
                    type: object
                    properties:
                      status:
                        const: waiting
                        description: Your person has not approved yet.
                      claimUrl:
                        type: string
                        description: Give this link to your person.
                      apiKey:
                        type: string
                        description: The key. Keep it secret. Shown once.
                  creditsUsed:
                    type: integer
                    const: 0
                  requestId:
                    type: string
        '202':
          description: Your person has not approved yet.
          headers:
            X-Request-ID:
              $ref: '#/components/headers/RequestId'
          content:
            application/json:
              schema:
                type: object
                required:
                  - success
                  - data
                  - creditsUsed
                  - requestId
                properties:
                  success:
                    const: true
                  data:
                    type: object
                    properties:
                      status:
                        const: waiting
                        description: Your person has not approved yet.
                      claimUrl:
                        type: string
                        description: Give this link to your person.
                      apiKey:
                        type: string
                        description: The key. Keep it secret. Shown once.
                  creditsUsed:
                    type: integer
                    const: 0
                  requestId:
                    type: string
        4XX:
          $ref: '#/components/responses/Error'
        5XX:
          $ref: '#/components/responses/Error'
      security: []
components:
  headers:
    RequestId:
      description: The request id. Quote it when you report a problem.
      schema:
        type: string
    RetryAfter:
      description: Seconds to wait before retrying.
      schema:
        type: integer
  responses:
    Error:
      description: The request failed. Retry-After says when trying again can help.
      headers:
        X-Request-ID:
          $ref: '#/components/headers/RequestId'
        Retry-After:
          $ref: '#/components/headers/RetryAfter'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  schemas:
    Error:
      type: object
      required:
        - success
        - error
        - code
      properties:
        success:
          const: false
        error:
          type: string
          description: What went wrong and what to do next.
        code:
          type: string
          enum:
            - apiKeyRequired
            - cliSessionCompleted
            - cliSessionExists
            - cliSessionNotFound
            - forbidden
            - freeLimit
            - insufficientCredits
            - internalError
            - inviteClaimed
            - inviteDisabled
            - inviteExpired
            - inviteUsedUp
            - invalidCliSession
            - invalidCliVerifier
            - invalidRequest
            - jobFinished
            - methodNotAllowed
            - notFound
            - payloadTooLarge
            - profileBusy
            - profileTooLarge
            - rateLimited
            - sourceChanged
            - sourceRefused
            - siteNotRead
            - sourceTimeout
            - sourceUnavailable
            - unauthorized
            - unsupportedMediaType
        retryAfterSeconds:
          type: integer
        signupUrl:
          type: string
          const: https://stophy.dev/signup
          description: >-
            Where a person gets a key. Sent with apiKeyRequired, freeLimit and
            an invalid key.
        signup:
          type: string
          const: POST https://api.stophy.dev/v1/signup
          description: >-
            The call that gets an agent a key with no human. Sent next to
            signupUrl.
  securitySchemes:
    apiKey:
      type: http
      scheme: bearer

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.