Langfuse API

Name: Langfuse API API
Brand: Langfuse API
Availability: InStock

✓ Official Vendor SpecAI/MLMl InferenceBasicAuth51 EndpointsREST

For Agents

Monitor LLM application traces, manage prompts, score generations, and track dataset runs for production LLM systems.

Connect the Langfuse API to your agent

Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Langfuse API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.

Install Jentic One Beta (Self-Hosted)

Jentic One Host machine

# On the machine that will host your Jentic One instance:
curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh

Agent machine

# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh
jentic register       # connects your agent to your Jentic One instance

Jentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.

Capabilities

What an agent can do with Langfuse API API.

Ingest traces, spans, and generations from LLM applications with full observability metadata

Track token usage, latency, and cost across models and providers

Score LLM outputs with custom evaluations or human-in-the-loop annotations

Manage prompt versions with a centralized registry that supports rollback and comparison

GET STARTED

Start building with Langfuse API API

Explore with Jentic

View OpenAPI Document

Use Cases

Patterns agents use Langfuse API API for, with concrete tasks.

★ Production LLM Observability

Track every LLM call in production with full trace context, including tokens, latency, model, and cost. Langfuse captures generations, spans, and events in a hierarchical trace structure, so you can debug failures, monitor quality drift, and optimize for cost without instrumenting every endpoint manually. Agents use the batch ingestion endpoint to send trace data asynchronously without blocking inference.

Ingest a batch of traces with generations, including model name, token counts, latency, and metadata, then retrieve the trace by ID to verify it was logged

Prompt Management and Versioning

Store prompts in Langfuse's centralized registry and version them alongside code changes. Pull the latest prompt at runtime by name, or pin to a specific version for stability. Agents can fetch prompts directly from the API instead of hardcoding them, enabling prompt iteration without redeploying code. Langfuse tracks which prompt version produced which outputs, so you can measure impact and roll back regressions.

Retrieve the latest version of a prompt named 'customer_support_agent' and include it in an LLM generation request

LLM Output Scoring and Evaluation

Attach scores to traces and observations to measure quality, factuality, or task success. Scores can come from automated evaluators (like LLM-as-judge or rule-based checks) or human annotators via annotation queues. Langfuse aggregates scores by session, user, or model to surface trends and regressions. Agents use the scoring API to log evaluation results alongside production traffic.

Create a score for a trace with a value of 0.85, category 'accuracy', and comment 'Retrieved correct product details'

Dataset-Driven Regression Testing

Build datasets of input-output pairs in Langfuse and run them through your LLM application to catch regressions before deploying prompt or model changes. Each dataset run tracks scores, latency, and costs across all items, so you can compare versions side-by-side. Agents use the dataset items API to fetch test cases and the dataset runs API to log results, automating the full evaluation loop.

List all items in a dataset named 'customer_queries_v3', run each through an LLM, and create a dataset run with scores for each item

Agent Integration via Jentic

AI agents use Langfuse through Jentic to log observability data without managing credentials or parsing API responses manually. An agent can search Jentic for 'track an LLM generation', load the ingestion endpoint schema, and execute it with structured trace data — all in under a minute. Jentic handles authentication via the secure vault, so the agent never sees raw API keys. This workflow turns observability from a 2-day integration into a single API call.

Search Jentic for 'ingest a trace with token usage', load the schema, and execute the API call with a sample trace containing model, input, output, and cost metadata

Key Endpoints

51 endpoints — public api for langfuse, an open source llm engineering platform that provides observability, metrics, evaluations, prompt management, and a playground for debugging and testing llm applications.

METHOD

PATH

DESCRIPTION

POST

/api/public/ingestion

Batch ingest traces, observations, and events

GET

/api/public/traces

List all traces with filtering and pagination

GET

/api/public/traces/{traceId}

Retrieve a single trace by ID

GET

/api/public/observations/{observationId}

Get a specific observation (generation, span, or event)

POST

/api/public/scores

Create a score for an observation or trace

GET

/api/public/v2/prompts

List all prompts in the registry

GET

/api/public/v2/prompts/{promptName}

Retrieve a prompt by name with version history

GET

/api/public/dataset-items

List dataset items for evaluation

POST

/api/public/ingestion

Batch ingest traces, observations, and events

GET

/api/public/traces

List all traces with filtering and pagination

GET

/api/public/traces/{traceId}

Retrieve a single trace by ID

GET

/api/public/observations/{observationId}

Get a specific observation (generation, span, or event)

POST

/api/public/scores

Create a score for an observation or trace

Why though Jentic?

Three things that make agents converge on Jentic-routed access.

Credential isolation

Langfuse API keys (public and secret) are stored encrypted in the Jentic vault. Agents receive scoped access tokens — raw keys never enter the agent's context.

Intent-based discovery

Agents search by intent (e.g., 'track an LLM generation') and Jentic returns matching Langfuse operations with their input schemas, so the agent can call the right endpoint without reading API docs.

Time to first call

Direct Langfuse integration: 1-2 days for auth, trace ingestion, and prompt fetching. Through Jentic: under 1 hour — search, load schema, execute.

Related APIs

Alternatives and complements available in the Jentic catalogue.

Complementary

OpenAI API

Language model inference — Langfuse observes OpenAI API calls

Use OpenAI for LLM inference, Langfuse for observability of those calls. Agents chain them: call OpenAI, log the trace to Langfuse.

Complementary

Anthropic API

Claude model inference — Langfuse tracks Anthropic API usage

Use Anthropic for Claude completions, Langfuse for monitoring. Same pattern as OpenAI: inference + observability layer.

Complementary

Hugging Face API

Open model inference — Langfuse observes Hugging Face API calls

Use Hugging Face for inference on open models, Langfuse for tracking. Agents log Hugging Face generations to Langfuse traces.

Complementary

Replicate API

Model inference platform — Langfuse monitors Replicate API calls

Use Replicate for inference across many models, Langfuse for unified observability. Log predictions from Replicate as observations in Langfuse.

Alternative

Sentry API

General application monitoring — broader scope but not LLM-specific

Use Sentry for error tracking across the full stack, Langfuse for LLM-specific observability. Langfuse captures LLM-native metadata (tokens, prompts, scores) that Sentry does not.

FAQs

Specific to using Langfuse API API through Jentic.

What authentication does the Langfuse API use?

The Langfuse API uses HTTP Basic Authentication. You provide your public key as the username and secret key as the password. Jentic stores these credentials encrypted in the secure vault, so agents receive scoped access tokens instead of raw keys.

Can I track traces across multi-turn agent conversations with the Langfuse API?

Yes. Use the sessionId field when ingesting traces to group all LLM calls from a single conversation. You can then query all traces for a session via GET /api/public/traces with a session filter, or retrieve session-level metrics via GET /api/public/sessions/{sessionId}.

What are the rate limits for the Langfuse API?

Rate limits depend on your Langfuse plan. The API returns 429 status codes when limits are exceeded. Check the X-RateLimit headers in responses for current limit and reset times. For high-volume production workloads, use the batch ingestion endpoint to reduce request count.

How do I retrieve a specific prompt version with the Langfuse API through Jentic?

Search Jentic for 'get a prompt from langfuse', load the GET /api/public/v2/prompts/{promptName} endpoint schema, and execute it with the prompt name. The response includes all versions, with the latest marked by default. You can pin to a specific version by adding a version query parameter.

Can I score LLM outputs automatically with the Langfuse API?

Yes. Use POST /api/public/scores to attach scores to traces or observations. You can automate scoring by running evaluators (LLM-as-judge, rule-based checks, or custom logic) and sending scores via the API. Scores support numeric values, categories, and optional comments for debugging.

Does the Langfuse API support annotation queues for human review?

Yes. Create annotation queues via POST /api/public/annotation-queues, add items (traces or observations) to the queue, and assign them to reviewers. Reviewers update item status via PATCH /api/public/annotation-queues/{queueId}/items/{itemId}. This enables human-in-the-loop workflows for quality control.

How do I filter traces by metadata in the Langfuse API?

Use the GET /api/public/traces endpoint with query parameters. You can filter by sessionId, userId, tags, metadata fields, or time ranges. The API returns paginated results with a cursor for large result sets. Agents typically search Jentic for 'list traces with filters' and execute with structured query parameters.