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

# Langfuse

> Pull your existing Langfuse traces into Hone — no re-instrumentation. Backfill history and stream new traces into Hone's eval, mining, and healing loop.

If you already run [Langfuse](https://langfuse.com) for observability, Hone can
ingest your traces directly — **no SDK changes, no re-instrumentation**. Hone
reads your Langfuse project, backfills history, and streams new traces into the
same eval / mining / healing loop as native Hone data.

## How it works

```
Langfuse project ──(pull, public API)──▶ Hone connector ──▶ Hone
   traces + observations                  maps + delivers      Raw Logs · User Stories · Evals
```

Hone lists your traces (`GET /api/public/traces`, paginated by time) and fetches
each trace's observations, then maps them to Hone's model. Every observation
keeps its Langfuse id, so re-syncing an overlapping window is idempotent.

## Connect (dashboard)

1. In Langfuse, open **Settings → API Keys** and create a key pair. Copy the
   **Public key** (`pk-lf-…`) and **Secret key** (`sk-lf-…`), and note your host
   (e.g. `https://us.cloud.langfuse.com` or `https://cloud.langfuse.com`).
2. In Hone, go to **Settings → Connections → Langfuse** and paste the host and
   keys. Optionally set:
   * **Customer-id metadata key** — the Langfuse metadata field Hone treats as
     your downstream tenant (`customer_id` by default).
   * **Backfill from** — an ISO date to bound history (blank = everything).
3. Save. Hone backfills, then keeps syncing new traces.

<Note>
  Your Langfuse secret key is used server-side only, to read your project. Grant a
  key with the least privilege your Langfuse plan allows.
</Note>

## What gets mapped

| Langfuse                              | Hone                                                   |
| ------------------------------------- | ------------------------------------------------------ |
| trace                                 | session (`sessionId ?? id`, `userId`, tags + metadata) |
| observation `GENERATION`              | agent turn                                             |
| observation `SPAN`                    | tool call                                              |
| observation `EVENT`                   | resource                                               |
| `parentObservationId`                 | parent event (call graph)                              |
| observation `id`                      | event id (idempotent re-sync)                          |
| metadata `customer_id` (configurable) | downstream tenant                                      |

Once ingested, your Langfuse conversations show up in **Raw Logs** and **User
Stories**, get scored by the online eval runner (**Evals**), and are eligible
for eval mining and auto-healing — exactly like agents instrumented with the
Hone SDK.

## Real-time (OpenTelemetry)

Langfuse is itself an OpenTelemetry backend, so if your app emits OTel you can
add a **second OTLP exporter** pointing at Hone's collector for real-time
delivery alongside the pull sync. See [Authentication](/authentication) for
endpoints, or reach out and we'll help wire it.