Install Jentic One Beta
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.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Flangfuse%2Flangfuse" | shStep 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Flangfuse%2Flangfuse" | sh
jentic register # connects your agent to your Jentic One instanceJentic 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.
What an agent can do with Langfuse 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
Query traces and observations with filtering by session, user, tags, or metadata
GET STARTED
Create annotation queues for human review of model outputs
Run dataset-based evaluations to measure regression in prompt quality
Patterns agents use Langfuse 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
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
/api/public/ingestion
Batch ingest traces, observations, and events
/api/public/traces
List all traces with filtering and pagination
/api/public/traces/{traceId}
Retrieve a single trace by ID
/api/public/observations/{observationId}
Get a specific observation (generation, span, or event)
/api/public/scores
Create a score for an observation or trace
/api/public/v2/prompts
List all prompts in the registry
/api/public/v2/prompts/{promptName}
Retrieve a prompt by name with version history
/api/public/dataset-items
List dataset items for evaluation
/api/public/ingestion
Batch ingest traces, observations, and events
/api/public/traces
List all traces with filtering and pagination
/api/public/traces/{traceId}
Retrieve a single trace by ID
/api/public/observations/{observationId}
Get a specific observation (generation, span, or event)
/api/public/scores
Create a score for an observation or trace
/api/public/v2/prompts
List all prompts in the registry
/api/public/v2/prompts/{promptName}
Retrieve a prompt by name with version history
What agents get from Jentic-routed access to this vendor.
Setup
Wiring the Langfuse API by hand means setting up its basic auth from a public and secret key pair, targeting your Langfuse host, and pointing the SDK at the ingestion and prompt endpoints yourself. Through Jentic you install once, import the Langfuse API from the API Directory, store the key pair once, and your agent calls it.
Permission scoping
You choose which Langfuse operations the agent may call, so you can limit it to the ones it needs, such as ingesting events, reading traces, or fetching a prompt version. Allowing trace and observation reads lets the agent inspect a run without gaining the ability to submit scores.
Credential isolation
Your Langfuse public and secret keys are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
Intent-based discovery
Agents search Jentic by intent such as 'track an LLM generation' or 'fetch a prompt by name', and Jentic returns the matching Langfuse operation with its input schema so the agent calls the right endpoint without reading the API docs.
Alternatives and complements available in the Jentic catalogue.
Specific to using Langfuse 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.
Can I limit what my agent is allowed to do with the Langfuse API?
Yes. Because you run Jentic One yourself, your own rules decide which Langfuse operations the agent may call, so you can restrict it to just the ones it needs, such as ingesting events, reading traces, or fetching a prompt version. For example, you can allow trace and observation reads via GET /api/public/traces without granting the ability to submit scores through POST /api/public/scores. Your Langfuse public and secret keys stay stored and injected at execution time, so the agent can only exercise the endpoints you permit.
For Agents
Monitor LLM application traces, manage prompts, score generations, and track dataset runs for production LLM systems.
Use for: I need to track an LLM generation with tokens and cost, I want to create a scored evaluation for my agent's output, Retrieve all traces for a specific session, List dataset items for prompt regression testing
Not supported: Does not handle LLM inference, model hosting, or vector storage - use for observability and prompt management of existing LLM applications only.
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. Track generations, spans, and traces across your LLM application stack. Monitor costs, latency, and quality scores with production-grade analytics. Manage and version prompts with a centralized registry that integrates into agent workflows.
/api/public/dataset-items
List dataset items for evaluation