Unable to use multiple Langfuse projects in the same application with CallbackHandler v4.x (Typescript)

[vilmiran]

Hi,

I’ve recently upgraded from typescript @langfuse/langchain v3.x to v4.x, and I’ve encountered a limitation regarding the usage of multiple Langfuse projects in a single application.

Previous behavior (v3.x):
In v3.x, I was able to pass different publicKey, secretKey, and baseUrl directly to the CallbackHandler constructor:

new CallbackHandler({
secretKey,
publicKey,
baseUrl,
userId,
sessionId,
tags,
metadata
});
This allowed me to send traces to different Langfuse projects within the same app.

Current behavior (v4.x):
With @langfuse/langchain@^4.2.1, the CallbackHandler constructor only accepts user/session metadata, and the Langfuse client configuration (publicKey, secretKey, baseUrl) is only read from environment variables:

new CallbackHandler({
userId,
sessionId,
tags,
traceMetadata
});

I cannot find a way to use different credentials for different projects in the same process. The docs seem to recommend only global environment variables, which prevents sending traces to multiple Langfuse projects from a single app instance.

Could you please advise on how to send traces to multiple Langfuse projects from a single TypeScript application, or if there is a recommended workaround for this scenario?

Thank you!!

[inkeep-ai-assistant[bot]]

---

The limitation you're encountering is a known constraint when using the Langfuse LangChain integration with multiple projects.(1)

In the Python SDK, there was a similar issue where the CallbackHandler only accepted a public_key parameter and relied on the LANGFUSE_SECRET_KEY environment variable, making multi-project setups difficult.(1) A fix was implemented for Python, but the same architectural limitation exists in the TypeScript integration.

Current Status:
Multi-project setups in Langfuse are currently experimental and come with significant caveats.(1) Most notably:

• Multi-project setups work exclusively if you have only the Langfuse SDK emitting OTEL spans in your application(1)
• Spans from third-party libraries will be sent to all projects(1)
• Only spans emitted by the Langfuse SDK and its managed integrations (LangChain, OpenAI) will be routed to specific projects(1)

Recommended Approach:
The current best practice for multi-project scenarios is to isolate processes or use synchronous code paths.(1) If you must support multiple projects in the same process, consider:

1. Using separate service instances for each Langfuse project
2. Implementing process-level isolation where each project runs in its own environment with distinct environment variables
3. Following the experimental multi-project setup guidance (though this is primarily documented for Python SDK v3)(1)

Unfortunately, there isn't currently a supported way to pass different credentials per-request to the TypeScript CallbackHandler in v4.x. The architecture relies on global configuration through environment variables, which prevents the flexible multi-project usage you had in v3.x.

📚 Sources:

1. bug: Langchain CallbackHandler fails in multi-project setting if LANGFUSE_SECRET_KEY env not set

---

Have another question? Just tag @inkeep.

[hassiebp]

@vilmiran Thanks for raising this! Are you looking for routing specific events to different projects (difficult to achieve currently), or would you like to simply export all events to multiple projects (possible via registering multiple LangfuseSpanProcessors with differently scoped keys in your OTEL setup)?

[vilmiran]

Hi,

What we are looking for is a single application that can send traces to different Langfuse projects.

We have an application in typescript that uses langchain and we enabled the langfuse callback provided by the langfuse-langchain library.

Our current situation is that we may have different use cases within one application (for example, a RAG use case, a chatbot use case, etc.). Until now, we sent traces for each use case to a separate Langfuse project this way using the CallbackHandler in v3:

new CallbackHandler({
secretKey,
publicKey,
baseUrl,
userId,
sessionId,
tags,
metadata
});
Each langchain chain defined its own CallbackHandler.

Now, with v4, we can only send all traces from an application to a single project, which makes it harder to manage permissions and governance for each use case. We have configured the Open Telemetry with the secret and public keys:
const sdk = new NodeSDK({
spanProcessors: [new LangfuseSpanProcessor({
secretKey,
publicKey,
baseUrl
})],
});
sdk.start();

And then we add the Callback handler at langchain chain, but now we cannot modify the public and secret keys.
return new CallbackHandler({
userId,
sessionId,
tags
});

We need version 4 to support what was possible in version 3.

Thanks a lot!!!

[hassiebp]

@vilmiran This is unfortunately not directly supported currently with the TypeScript SDK v4. Is there a way for you to keep every use case in the same project and differentiate by trace names etc. on their use case, or do you have a permissions-related reason for splitting them into different projects?

[vilmiran]

Hi,

We have managed to send traces to different Langfuse projects from the same application. From what we understand, Open Telemetry allows you to define an array of Span Processors to send traces to different "systems."

We have added the LangfuseSpanProcessor twice, configuring each instance with the keys that point to a specific project.
Using the shouldExportSpan method, we define the condition for the Span Processor to send the trace. In this case, we manage it with tags: if the trace has a specific tag, it gets sent.
The inclusion of these tags is handled centrally by our architecture layer; the tags for the use case are automatically added to all traces.

const sdk = new NodeSDK({
   spanProcessors: [
      new LangfuseSpanProcessor({
         secretKey: secretKey1,
         publicKey: publicKey1,
         baseUrl,
         shouldExportSpan: ({ otelSpan }) => {
            const tags = otelSpan.attributes['langfuse.trace.tags'] as string[] | undefined;
            return tags ? tags.includes(`XXXXX`) : false;
          }
     }),

    new LangfuseSpanProcessor({
         secretKey: secretKey2,
         publicKey: publicKey2,
         baseUrl,
         shouldExportSpan: ({ otelSpan }) => {
            const tags = otelSpan.attributes['langfuse.trace.tags'] as string[] | undefined;
            return tags ? tags.includes(`YYYYY`) : false;
          }
     })

   ],
});



sdk.start();

Do you see any issues with using it this way?

Thanks.

[hassiebp]

@vilmiran while correct in principle, this will be filtering out all spans that miss the the langfuse.trace.tags attribute.

We have plans to add a propagateAttributes helper that will automatically set attributes on all spans in a context. This will be exactly what you are looking for, PR is not yet merged though but this will land in the coming days:

langfuse/langfuse-js#676

[vilmiran]

What you mention sounds promising and seems like it could help us solve the problem. Currently, although we’re able to route and send traces to multiple projects as you described, only the parent trace is being sent to the Langfuse project.

We tested the code from the pull request, but we noticed that in the onStart method of the LangfuseSpanProcessor, the parent context appears empty, so nothing is propagated to the child spans.

Do we need to modify anything else in the code to make it work as expected?

[hassiebp]

We have shipped the feature in JS SDK v4.4.0 - could you please upgrade and try again?

[aumeshm]

@hassiebp we are running into the same issue. We have many langfuse projects and different api keys/ project. Depending on the organization that's is invoking the function. We use a separate langfuse config and send those specific traces to that. Whats the best workable solution to get around this?

We are also using the manual method for observations (since that is most similar to v3 for now)