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

# Put the same check in your product

> Run Proofable checks inside your own product with the SDK, so your server makes the final access decision.

Define requirements in your product and enforce the result on your server. Proofable reuses existing proof before asking the user to verify again.

```javascript theme={"system"}
import { ProofableClient, defineGate } from '@proofable/sdk';

const client = new ProofableClient();
const gate = defineGate([{ verifierId: 'proof-of-human' }]);
const result = await client.gateCheck({
  gate,
  subject: { accountId: user.accountAddress },
});

if (!result.satisfied) throw new Error('Verification required');
await submitReview();
```

No dashboard or published listing is required. Your application owns the final allow or deny decision.

<Tabs>
  <Tab title="Missing verification">
    Use Hosted Verify only when the server check reports a missing verifier.

    ```js theme={"system"}
    import { getHostedCheckoutUrl } from '@proofable/sdk';

    window.location.assign(
      getHostedCheckoutUrl({
        verifiers: ['proof-of-human'],
        returnUrl: 'https://app.example.com/callback',
      }),
    );
    ```

    Re-run the server check after the user returns. Pass `mode: 'popup'` and `origin` to keep people on your page. [Hosted verification](/verification/hosted)
  </Tab>

  <Tab title="SDK">
    ```bash theme={"system"}
    npm install @proofable/sdk
    ```

    | Job | Method |
    | - | - |
    | Protect a page | `VerifyGate` |
    | Check access on your server | `gateCheck` |
    | Create proofs for a user who approved your app | `verifyFromApp` |
    | Create agents for your users | `getHostedAgentCreateUrl` |
    | Read a proof | `getProof` |

    [JavaScript SDK](/sdks/javascript)
  </Tab>

  <Tab title="API">
    Call `https://api.proofable.me` from any language.

    | Need | Endpoint |
    | - | - |
    | Check inline requirements | `POST /api/v1/proofs/check` |
    | Create a proof | `POST /api/v1/verification` |
    | Read a proof | `GET /api/v1/proofs/{qHash}` |
    | Load a gate | `GET /api/v1/profile/gates/{gateId}` |

    [HTTP API](/api/overview) and [OpenAPI](https://api.proofable.me/openapi.json)
  </Tab>
</Tabs>

## What your users get

| Your product needs | Proofable provides |
| - | - |
| Sign-in | Hosted passkey, wallet, and Google or Microsoft sign-in |
| Verified users | Checks that save reusable proofs |
| Agents for your users | An owner, identity, and permission proof for each agent |
| Access control | Verification UX in the browser; final decisions on your server |
| Payments | Visitor checkout and pay per call |

Users keep their proofs. When they reach another product that accepts them, they don't start over.

## Who pays

Your app can sponsor usage, users can pay through a Listing, and agents or APIs can use x402. Payer-resolution details are in [Pricing](/pricing).

## Keep credentials on the server

Access keys and other secrets never belong in browser code. Call Proofable from your backend when you need more than the SDK exposes in the browser.

## Next

<CardGroup cols={2}>
  <Card title="Server integrations" icon="server" href="/integrations/server">
    Create proofs from your backend.
  </Card>

  <Card title="Hosted verification" icon="key" href="/verification/hosted">
    Every parameter for the hosted flow.
  </Card>

  <Card title="Agents in the SDK" icon="robot" href="/sdks/agents">
    Create agents for your users with owner approval.
  </Card>

  <Card title="HTTP API" icon="terminal" href="/api/overview">
    Endpoints, paging, and raw requests.
  </Card>
</CardGroup>


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