# List logs

URL: https://docs.hanzo.ai/docs/openapi/platform/get-platform-projects-by-project-apps-by-app-deployments-by-id-logs

> Returns real logs for a deployment — the build's, then the app's.

`GET /v1/platform/projects/{project}/apps/{app}/deployments/{id}/logs`

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

|               |                                                                                        |
| ------------- | -------------------------------------------------------------------------------------- |
| **Address**   | `https://api.hanzo.ai/v1/platform/projects/{project}/apps/{app}/deployments/{id}/logs` |
| **Method**    | `GET`                                                                                  |
| **Operation** | `get_platform_projects_by_project_apps_by_app_deployments_by_id_logs`                  |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`                                                 |

Returns real logs for a deployment — the build's, then the app's.

It returns the deployment's recorded status timeline together with LIVE pod logs
pulled from the cluster: the build pod's output while a git build is running, and
the running app's output once it is deployed. The `source` field says which of
the two the body is — `build`, `app` or `none` — so a console can label the pane
honestly.

It never fabricates log content. When no pod exists yet, or the cluster is
unreachable, it degrades to the recorded timeline and says so. Every cluster read
is confined to the caller org's own namespaces and time-boxed. Requires a
validated principal; 401 without one.

## Request

3 fields.

| Field     | In   | Type   | Required | Description                                                        |
| --------- | ---- | ------ | -------- | ------------------------------------------------------------------ |
| `project` | path | string | yes      | Project is the project the application lives under, from the path. |
| `app`     | path | string | yes      | App is the application's slug, from the path.                      |
| `id`      | path | string | yes      | ID is the deployment's id, from the path.                          |

## Response

| Status    | Body                | Meaning |
| --------- | ------------------- | ------- |
| `200`     | platform.deployLogs | ok      |
| `default` | problem-details     | refused |

`200` body — 3 fields.

| Field          | In   | Type   | Always | Description                                                                                                                                       |
| -------------- | ---- | ------ | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `deploymentId` | body | string | —      | DeploymentID is the deployment these logs belong to.                                                                                              |
| `logs`         | body | string | —      | Logs is the recorded status timeline followed by the streamed pod output, newline-separated.                                                      |
| `source`       | body | string | —      | Source says which pod the log body carries — `build`, `app`, or `none` when neither pod was reachable — so a console can label the pane honestly. |

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

## Examples

**CLI**

```bash
hanzo platform projects apps deployments logs <project> <app> <id>
```

**SDK**

**.ts**

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

const api = new PlatformApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getPlatformProjectsByProjectAppsByAppDeploymentsByIdLogs({ project: 'project', app: 'app', id: 'id' });
```

**.py**

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = PlatformApi(client).get_platform_projects_by_project_apps_by_app_deployments_by_id_logs(project='project', app='app', id='id')
```

**.go**

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

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

**.rs**

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

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

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

**.java**

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

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

var result = new PlatformApi(client).getPlatformProjectsByProjectAppsByAppDeploymentsByIdLogs();
```

**HTTP**

```bash
curl https://api.hanzo.ai/v1/platform/projects/<project>/apps/<app>/deployments/<id>/logs \
  -H "Authorization: Bearer $HANZO_API_KEY"
```

**MCP**

MCP reaches **platform** through the `platform` tool, which names its 38 operations with its own verbs — this one among them, under a name only MCP declares. `describe` explains any of them:

```bash
curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "get_build"
         }
       }
     }'
```

---

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