OpenTelemetry-native observability for any TypeScript or Node.js app, from the team behind Pydantic. A first-party SDK, automatic instrumentation for the libraries you already use, and SQL over everything it collects. Free for 10 million spans, logs, and metrics a month.
npm install @pydantic/logfire-node @opentelemetry/auto-instrumentations-node
export LOGFIRE_TOKEN=your-write-token # Settings > Write tokens// instrumentation.ts
import * as logfire from '@pydantic/logfire-node'
logfire.configure({
serviceName: 'my-app',
serviceVersion: '1.0.0',
environment: 'production',
})npx tsx --import ./instrumentation.ts server.ts
The instrumentation file has to load first. Automatic instrumentation wraps each library as Node loads it, so anything imported
before logfire.configure() runs is never patched. Full details are in the TypeScript setup guide.
What lands in Logfire:
undici and http spans for the requestpg query and pool checkout, timedawait logfire.span('process-order', {
callback: async () => {
logfire.info('Order processed')
},
})
Spans nest inside whatever is already open, so your own operations sit in the same trace as the request and queries that triggered them. Call
await logfire.shutdown() before a short-lived script exits so pending telemetry is flushed.
Logfire ships maintained TypeScript packages: @pydantic/logfire-node for the server, plus browser and Cloudflare Workers builds. You configure a service and start tracing, rather than assembling an OpenTelemetry exporter, a resource, and a tracer provider by hand.
Add @opentelemetry/auto-instrumentations-node and your HTTP server, database driver, and outbound calls become spans without touching their call sites. Every incoming request opens a trace, and the work inside it is attached as timed child spans.
Automatic instrumentation wraps each library as Node loads it, which is why the instrumentation file must load first, and why bundling breaks it. Rather than pretend one snippet works everywhere, there are specific guides for Express, Next.js, Deno, and the Vercel AI SDK.
Mastra, the Vercel AI SDK, VoltAgent, LangChain.js, LangGraph.js and LlamaIndex.TS all send telemetry to Logfire, so your agent runs and model calls land in the same traces as the HTTP requests and queries around them. Pick your framework on its merits, not on what your observability tool happens to support.
Logfire is not just tracing. Send metrics and structured logs alongside your traces, build dashboards, and set alerts, all in the same OpenTelemetry-native project, and query all of it with the same SQL.
Because Logfire speaks OpenTelemetry natively, standard OTel instrumentation and manual spans work unchanged, and you can send the same data to another backend or self-host without touching your instrumentation. Your instrumentation is an asset you own, not rented from a vendor.
select
attributes->>'http.route' as route,
count(*) as requests,
avg(duration) as avg_seconds
from records
where duration > 1
group by route
order by avg_seconds desc;Your traces, metrics, and logs are queryable with real SQL, no proprietary query language to learn. Any question you can express becomes a dashboard, an alert, or a one-off investigation.
“You can tell that Pydantic Logfire was built by people who use it.”
Install @pydantic/logfire-node, create an instrumentation.ts file that calls logfire.configure() with your service name, and load that file before your application starts, for example with npx tsx --import ./instrumentation.ts server.ts. Add @opentelemetry/auto-instrumentations-node and the libraries you already use are traced automatically.
Almost always load order or bundling. Automatic instrumentation wraps each library as Node loads it, so the instrumentation file has to load before anything it is meant to patch. Bundlers also prevent automatic traces from working because modules are inlined rather than loaded at runtime; in that case follow the framework-specific guide instead of the generic setup.
Yes. Each has its own guide, because how and when you load the instrumentation differs by framework and bundler. The underlying SDK is the same; only the loading strategy changes.
For short-lived scripts, yes. Call await logfire.shutdown() before exit so buffered spans are sent. Long-running servers export continuously in the background and do not need this on every request.
No. Logfire is built on OpenTelemetry, the open industry standard. Standard OTel instrumentation works unchanged, your instrumentation is portable to any OTel-compatible backend, and you can self-host without rewriting it.
Get started with 10 million free spans, logs, and metrics per month. No credit card required.