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

# Jurat Recovery Integration Guide

> Integrate Jurat recovery and probate into a wallet or web3 application.

Jurat gives wallets and web3 applications a recovery and probate layer for self-custodied assets.

You can integrate Jurat in three ways:

* Link users to the hosted app at [app.jurat.io](https://app.jurat.io).
* Call the `/api/v1` endpoints directly from your frontend or backend.
* Use the planned TypeScript SDK after the API contract is finalized and the SDK package is published.

## What Jurat Provides

* Recovery case APIs for Jurat Legal Code creation, duplicate checks, court metadata submission, and case status tracking.
* Estate and probate APIs for estate profiles, privacy codes, terms acceptance, and will uploads.
* Developer dashboard credentials for API-key based server integrations.
* A planned TypeScript SDK that will wrap API calls and canonical wallet-signature messages after the API is finalized.

## Base URLs

Production API:

```txt theme={null}
https://api.jurat.io/api/v1
```

Hosted app:

```txt theme={null}
https://app.jurat.io
```

Developer docs:

```txt theme={null}
https://docs.jurat.io
```

## Integration Options

### Link To The Hosted App

Send users to:

```txt theme={null}
https://app.jurat.io
```

This is the fastest path if you want to support Jurat recovery and probate without building a custom user experience.

### Planned SDK

Jurat will publish a TypeScript SDK after the API work is wrapped up. The SDK is expected to live in its own codebase and package, separate from the hosted app.

### Call The APIs Directly

Call the stable API namespaces directly:

```txt theme={null}
/api/v1/recovery-cases
/api/v1/estate-profiles
```

Direct API access is best for wallets, custodians, and account-abstraction providers with custom backend workflows.

Server-side API integrations can use API keys issued from the hosted developer dashboard at:

```txt theme={null}
https://app.jurat.io/developers
```

Read [Authentication And API Keys](/authentication) before storing or using production credentials.

## Signing Model

Most public integration endpoints use wallet signatures to prove user intent.

The planned SDK is expected to use this minimal signer interface:

```ts theme={null}
type JuratSigner = {
  address: string;
  signMessage(message: string): Promise<string>;
};
```

This shape works with ethers, viem, wagmi, Privy, embedded wallets, RainbowKit, account-abstraction clients, and custody providers.

## Recovery Flow

The recovery flow has three phases:

1. Create a recovery intent and generate a Jurat Legal Code hash.
2. File the legal process using the generated hash.
3. Submit court-order metadata so Jurat can verify the court docket and execute recovery on-chain.

## Estate And Probate Flow

Estate profiles let users prepare probate information connected to a wallet:

* Fetch or create an estate profile.
* Create probate privacy codes.
* Upload signed will documents.
* Resolve privacy codes for probate discovery workflows.

## Next Steps

* Start with the [API Quickstart](/api-quickstart) if you want to call the API directly.
* Read [Authentication And API Keys](/authentication) if you need server-side API credentials.
* Read [Signing](/signing) before implementing direct API calls.
* Review the [SDK Preview](/sdk-quickstart) only if you are planning a future embedded integration.