Langfuse vs LangSmith: Pricing, Self-Hosting, OpenTelemetry and an X-Data Agent Traced in Both

Every row below comes from the vendor's own pricing page, docs or repository, read this session. Where a vendor does not publish a number, the table says so instead of guessing.

Read the units before the prices. A LangSmith trace is a whole run, so a 3-step agent costs one trace. A Langfuse unit is every data point, so the same run is roughly 5 units (the trace, three observations and one score). That is why "$8 per 100k" and "$0.005 per trace" cannot be compared directly, and why the worked example below does the conversion.

Ownership note. The Langfuse repository's LICENSE file now carries a "Copyright (c) 2023-2026 ClickHouse, Inc." line, and the self-hosted pricing page says Langfuse's enterprise pricing is "additive to your ClickHouse commercial plan". The MIT terms for everything outside the ee/ directories are unchanged.

Evals, prompts and datasets: the feature lists overlap almost completely. The difference is where each feature lives and what it costs.

Langfuse. The self-hosted pricing page lists observability, evaluation, prompt management, datasets, the playground, prompt experiments, LLM-as-judge evaluators and human annotation queues as part of the MIT open-source core. What sits behind the enterprise license is administrative: project-level RBAC, data retention management, audit logs, server-side data masking, SCIM and instance management APIs. Prompts are versioned and can be released by label, which lets a deploy pull "production" instead of a hard-coded version.

LangSmith. The pricing page lists tracing, monitoring, insights, online and offline evals, dataset collection, an annotation queue, Prompt Hub and Playground and bulk data export on every plan. Tuned Evaluators are metered at 0.015 LSU per run. LangSmith also sells adjacent products on the same bill (Deployment for long-running agents, Sandboxes, Fleet and Engine), which matters if you want one vendor for build, trace and deploy.

For an X-data agent specifically, the useful evals are inexpensive: did the fetch return posts, does the summary mention the top posts by engagement, does it stay under a length limit, and does it avoid quoting private accounts. All four run as code-based scores in either tool; only the judge-style "is this summary faithful" check needs an LLM evaluator.

Langfuse cloud plans. Hobby is free with no credit card, 50k units a month and no overage billing, so it simply stops at the limit. Core is $29 a month, Pro $199 a month and Enterprise $2,499 a month; each includes 100k units and then bills graduated overage: $8 per 100k from 100k to 1M units, $7 per 100k from 1M to 10M, $6.50 per 100k from 10M to 50M and $6 per 100k above 50M. Pro adds 3 years of data access, data retention management, SOC2 and ISO27001 reports and a HIPAA BAA; a Teams add-on for Pro costs $300 a month for enterprise SSO and fine-grained RBAC.

LangSmith plans. Developer is $0 per seat per month with one seat and up to 5k base traces, then pay as you go. Plus is $39 per seat per month with up to 10k base traces, unlimited seats at $39 each, and one free small serverless deployment. Enterprise is custom. The pricing page's tooltip prices extra traces at 0.005 LSU per base trace and 0.0025 LSU per extended-trace upgrade, and the page defines 1 LSU as $1. So 1,000 extra base traces cost $5, and 1,000 traces kept for 180 days cost $7.50.

Seats matter on LangSmith only. Langfuse Core and above have unlimited users; LangSmith Plus charges every user. A 5-person team on Plus pays $195 a month before any overage; the same team on Langfuse Core pays $29.

What is billed but not obvious. On LangSmith, automation rules (for example sampling 10% of traces for review, or keeping every errored trace) upgrade the whole trace to extended retention, which adds the 0.0025 LSU fee. Tuned Evaluators bill 0.015 LSU per evaluation run. On Langfuse, each score you attach is its own unit, so an eval that writes three scores per run triples that part of the bill.

Discounts. Langfuse lists 50% off the first year for early-stage startups, up to 100% off for research and students, $199 a month in credits for non-profits and $300 a month for open-source projects. LangSmith lists up to $10,000 in credits for VC-backed startups.

Take a small production agent: every run fetches recent posts about a topic from X, asks a model to summarize them, and records one quality score. Instrumented with decorators, one run produces one root observation, two child observations (fetch and summarize) and one score. In LangSmith that is 1 trace. In Langfuse it is about 5 units (1 trace + 3 observations + 1 score). Each run pulls one 20-post page from X.

How the LangSmith column is computed. Developer: (runs minus 5,000) x $0.005. Plus with one seat: $39 + (runs minus 10,000) x $0.005. Base retention (14 days) only; keeping traces 180 days adds $2.50 per 1,000.

How the X data columns are computed. Each run returns 20 posts. TwitterAPI.io bills 15 credits per tweet returned, which is $0.15 per 1,000 tweets ($0.003 for a full 20-tweet page). The official X API pay-per-usage rate card (docs.x.com) charges $0.005 per post read, $5 per 1,000, about 33x more per 1,000 posts. The official plan is also capped at 3M post reads a month before Enterprise.

The takeaway for this workload. Below about 10,000 runs a month both observability tools are free or close to it, and the X data line is the larger cost. Past that, the per-trace price on LangSmith grows linearly, while Langfuse's unit price stays low even though it counts more units per run. If your agent produces many observations per run (long tool chains, retrieval steps), redo the Langfuse math with your real observation count: a 40-step run is about 42 units.

Langfuse's Python SDK (v5 on PyPI this session, 5.2.0) wraps OpenTelemetry. The @observe decorator turns each function into an observation, and as_type="generation" marks the LLM step so tokens and cost show up in the generation view. The full runnable script is in the code block at the end of this page; the key parts:

Fetch step. fetch_posts calls /twitter/tweet/advanced_search with queryType=Latest, reads the top-level tweets[] list and follows has_next_page / next_cursor. Each tweet carries text, likeCount, viewCount and an author object. The decorator records the query as input and the trimmed list as output, so a bad summary can be traced back to the exact posts the model saw.

Score step. langfuse.create_score attaches a numeric score to the current trace. In production you would replace the toy non_empty check with an LLM-as-judge evaluator configured in the Langfuse UI, which runs in the MIT core on self-hosted instances too.

Flush. Short-lived scripts must call langfuse.flush() before exit, or the background exporter may drop the last batch. Long-running servers do not need it.

Self-hosted. Point LANGFUSE_BASE_URL at your own instance. The SDK v5 docs say it needs Langfuse server v4 (v4.59.0 or newer if self-hosted); the latest GitHub release this session is v4.76.0.

The LangSmith version is in the code block below. @traceable from the langsmith package does the same job; run_type="llm" marks the model step. Set LANGSMITH_TRACING=true and LANGSMITH_API_KEY and every call of run() becomes one trace in the project named by LANGSMITH_PROJECT. Inside LangChain or LangGraph you need no decorators at all: the environment variables alone turn tracing on, which is the integration advantage people cite for LangSmith.

If your stack already emits OpenTelemetry spans (the Vercel AI SDK, many agent frameworks, or your own instrumentation), you can send them to either tool without their SDKs. This is also the cleanest way to run both side by side during an evaluation.

One caveat on Langfuse's side: its docs state plainly that gRPC is not supported yet, so configure the HTTP exporter. LangSmith's docs recommend langsmith SDK 0.4.25 or later for non-LangChain OTel export, and 0.14.9 or later for agent-based workspaces that use the Langsmith-Agent-Id header.

We pulled every recent post X search returned for "langfuse langsmith" (reposts excluded) and kept the 419 whose text names both products. They come from 310 distinct authors; 248 are from 2026, 97 from 2025 and 71 from 2024. English leads (302 posts), then Japanese (70) and Chinese (26).

Almost nobody declares a winner. Only 9 posts (2.1%) state a choice by our keyword rules. 8 of them lean Langfuse and one names both as picks; none states a switch to LangSmith. Of the Langfuse picks, 4 cite self-hosting or open source, 2 cite price and 2 cite evals. With a sample this small, read it as "the people who write about switching tend to be leaving for Langfuse", not as market share.

The tools are mostly named together, not against each other. 18% of the posts are roundups that also name three or more other tools (Braintrust, Arize Phoenix, DeepEval and so on), and those roundups get the most reach: a median of 1,397 views vs 624 for the whole set. 40 posts (9.5%) share their opening 120 characters with another post in the sample, mostly copy-pasted "AI stack map" graphics.

Evals are what people talk about. 181 posts (43%) mention evals, 107 (26%) mention price or cost, 106 (25%) mention self-hosting or open source and 49 (12%) mention OpenTelemetry. LangChain ecosystem fit, the classic argument for LangSmith, appears in only 12.

Questions outnumber answers. 13 posts ask which one to use, more than the 9 that answer it.

We also read the latest timeline of each company account: 60 posts from @langfuse covering 74 days and 180 from @LangChain covering 29 days (LangSmith has no separate company account we could find; the older @LangChainAI handle returns "user not found").

Different jobs. @LangChain posts about 7.5x as often and covers the whole LangChain family (LangGraph, Deep Agents, LangSmith); only 13% of its posts name LangSmith. @langfuse posts less than once a day and stays on topic: 37% of its posts mention evals. Neither account named the other product in the sample.

Engagement per post is closer than follower counts suggest. @LangChain has about 41x the followers but only 1.5x the median likes per original post. For a team deciding which community to lean on, LangChain's reach is broader; Langfuse's audience is narrower and engaged.

Pick Langfuse if you need to self-host (data residency, a regulated customer, an air-gapped environment), you expect more than about 10,000 runs a month, your team has more than two or three people who need access, or you want to stay framework-neutral. Budget for running Postgres, ClickHouse, Redis and object storage if you self-host, or use the cloud plans.

Pick LangSmith if your agents are built on LangChain or LangGraph and you want tracing switched on by environment variables, you plan to deploy agents on LangSmith Deployment anyway, or you are a solo developer under 5,000 traces a month and want the shortest setup. Watch the per-seat line as the team grows and the extended-retention upgrades that automation rules trigger.

Run both for a week if you cannot decide. Emit OpenTelemetry spans once, switch TRACE_BACKEND in the OTel snippet above to send the same runs to each tool, then compare the trace views your team actually uses on real runs.

Wiring X data into either one. If the agent needs live X posts, profiles or followers, call the REST endpoints directly as in the code here, or connect the hosted MCP server at https://mcp.twitterapi.io/mcp with an Authorization: Bearer header so a model can call X tools itself; each tool call then shows up as a span in whichever tracer you picked. Reads need no X account. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days), which covers about 6,600 tweets of testing at $0.15 per 1,000 tweets.

One rate-limit note for agent builders: TwitterAPI.io allows 0.2 requests per second before the first payment and 20 once paid, so a scheduled agent that polls every minute fits easily, and a polling check that finds nothing costs the $0.00015 minimum (every 60 seconds for a month is $6.48).

Question. When people on X compare Langfuse and LangSmith, which one do they say they chose and why, and how do the two official accounts post?

Data. One X advanced search for posts containing both "langfuse" and "langsmith" (Latest, reposts excluded), 500 posts returned, 419 naming both in the text; plus the latest timelines of @langfuse (60 posts) and @LangChain (180 posts), and profile lookups for both accounts. Collected in 2026 through the TwitterAPI.io read endpoints /twitter/tweet/advanced_search, /twitter/user/last_tweets and /twitter/user/info.

Cost. 43 requests returned 740 tweets and 3 profiles, about $0.11 at 15 credits per tweet and 18 per profile. The same reads on the official X API pay-per-usage rate card ($0.005 per post read, $0.010 per user read) would cost about $3.73.

Method. Choices and themes are classified with transparent keyword rules (English, Japanese and Chinese phrasings such as "switched to", "we use", "self-host", "派"), published in analyze.py in our studies folder. Rules undercount implicit choices, cannot read sarcasm and treat a reply in a longer thread on its own.

What the sample cannot show. X search returns a recency-weighted subset, not every post ever written; posts that name only one tool are excluded by design; the official-account windows differ in length because the accounts post at different rates. None of this measures usage or market share.

Privacy. Aggregates only. The two organization accounts are named; authors of the comparison posts are private individuals and are not named, quoted or linked. Raw search pages were not stored; de-identified rows (year, language, category, engagement) are kept for reproducibility.