# Get stream

URL: https://docs.hanzo.ai/docs/openapi/patrol/get-patrol-camera-by-name-stream-by-ticket

> Redeems a minted ticket for what opens the camera.

`GET /v1/patrol/camera/{name}/stream/{ticket}`

> [Patrol →](https://docs.hanzo.ai/docs/openapi/patrol) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides)

|               |                                                                |
| ------------- | -------------------------------------------------------------- |
| **Address**   | `https://api.hanzo.ai/v1/patrol/camera/{name}/stream/{ticket}` |
| **Method**    | `GET`                                                          |
| **Operation** | `get_patrol_camera_by_name_stream_by_ticket`                   |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`                         |

Redeems a minted ticket for what opens the camera.

The mint is the operation's — staff only — and it hands back the camera's
address with the credential stripped out of it. This is where the holder of
that address gets what actually dials the camera, and it asks for no
credential of its own: whatever opens a camera is a relay, not a member of the
operation, and a check only the issuer could perform checks nothing.

The ticket IS the authority. It names one camera, it covers one moment, and it
is tagged with a key nobody but this deployment holds, so holding a live one is
the right to open that camera until it runs out — which is the whole of what
was issued, and the reason issuing one is staff-only and five minutes long.

A tag that does not verify is 404 — the route is no oracle on which tenants or
cameras exist, or which tickets were ever issued — and one that verifies but
has passed its moment is 410, because that ticket was real and is over.

## Request

3 fields.

| Field     | In    | Type   | Required | Description                                                                                                 |
| --------- | ----- | ------ | -------- | ----------------------------------------------------------------------------------------------------------- |
| `name`    | path  | string | yes      | Name is the camera's document name, from the path.                                                          |
| `ticket`  | path  | string | yes      | Ticket is the tag the minted address carries, from the path.                                                |
| `expires` | query | string | —        | Expires is the moment the tag covers, as the seconds the minted address carries in its `expires` parameter. |

## Response

| Status    | Body                   | Meaning |
| --------- | ---------------------- | ------- |
| `200`     | patrol.patrolTicketOut | ok      |
| `default` | problem-details        | refused |

`200` body — 3 fields.

| Field          | In   | Type                | Always | Description                                 |
| -------------- | ---- | ------------------- | ------ | ------------------------------------------- |
| `data`         | body | patrol.patrolStream | —      |                                             |
| `data.expires` | body | string              | —      | Expires is when that address stops working. |
| `data.url`     | body | string              | —      | URL is the address to open the stream at.   |

Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors).

## Examples

**CLI**

```bash
hanzo patrol camera stream get <name> <ticket>
```

**SDK**

**.ts**

```ts
import { Configuration, PatrolApi } from 'hanzoai';

const api = new PatrolApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getPatrolCameraByNameStreamByTicket({ name: 'name', ticket: 'ticket' });
```

**.py**

```python
from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import PatrolApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = PatrolApi(client).get_patrol_camera_by_name_stream_by_ticket(name='name', ticket='ticket')
```

**.go**

```go
cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.PatrolAPI.GetPatrolCameraByNameStreamByTicket(context.Background()).Execute()
if err != nil {
	return err
}
```

**.rs**

```rust
use hanzo_client::apis::{configuration::Configuration, patrol_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = patrol_api::get_patrol_camera_by_name_stream_by_ticket(&cfg, Default::default()).await?;
```

**.java**

```java
import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.PatrolApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new PatrolApi(client).getPatrolCameraByNameStreamByTicket();
```

**HTTP**

```bash
curl https://api.hanzo.ai/v1/patrol/camera/<name>/stream/<ticket> \
  -H "Authorization: Bearer $HANZO_API_KEY"
```

**MCP**

Tool `patrol`, op `get_patrol_camera_by_name_stream_by_ticket` — POST the JSON-RPC envelope to `https://api.hanzo.ai/v1/mcp`.

```bash
curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "patrol",
         "arguments": {
           "op": "get_patrol_camera_by_name_stream_by_ticket",
           "input": {
             "name": "<name>",
             "ticket": "<ticket>"
           }
         }
       }
     }'
```

---

[Patrol API](https://docs.hanzo.ai/docs/openapi/patrol) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)