PyBridge - TypeScript to Python Bridge

Accessing Python Functions in Node.js Made Easy.

PyBridge is a TypeScript library that simplifies the integration of Python functions into Node.js applications. It provides a seamless and type-safe approach, enabling developers to leverage the capabilities of Python, particularly in scenarios involving machine learning models. In this article, we will explore the features, use cases, and usage of PyBridge.

Using machine learning models in a full isomorphic TypeScript stack while relying on Python can present challenges. These include bridging the language barrier, ensuring type safety and data consistency, handling serialization and deserialization of complex data, and optimizing performance for efficient execution. PyBridge addresses these challenges, simplifying the integration process and enabling seamless utilization of Python machine learning models within a TypeScript codebase.

The library can be found here:


PyBridge offers the following key features:

  • TypeScript Type Support: PyBridge fully supports TypeScript types, including generics. This ensures type safety throughout the integration process.

  • Generator Function Support: PyBridge allows the usage of generator functions in Python, facilitating efficient streaming with libraries like RxJS.

  • Python Modules and Scripts: PyBridge seamlessly interacts with both Python modules and scripts, giving developers the flexibility to leverage existing Python code or create new functionalities.

  • Automatic Serialization and Deserialization: PyBridge automatically handles the serialization and deserialization of data between Node.js and Python, simplifying the data exchange process.

Use Cases

PyBridge is particularly useful in the following scenarios:

  • Calling Arbitrary Python Functions from Node.js: PyBridge enables developers to directly invoke any Python function from their Node.js codebase, expanding the range of available libraries and functionalities.

  • Using Machine Learning Models in Node.js: Python is widely used for developing machine learning models. With PyBridge, developers can seamlessly integrate these models into Node.js applications, harnessing the power of Python's machine learning ecosystem.

  • Fine-Tuning Machine Learning Models: PyBridge facilitates the fine-tuning of machine learning models using data from Node.js. This capability allows developers to adapt models to specific use cases and improve their predictive capabilities.

  • Text-Embedding: PyBridge simplifies the text-embedding process between Node.js/TypeScript and databases managed by Node.js. This is particularly valuable for applications that rely on natural language processing (NLP) tasks.


To demonstrate the usage of PyBridge, let's consider an example that integrates a Python function into a Node.js application.

Python Code (

from typing import List

def word_sizes(words: List[str]) -> List[int]:
    return [len(word) for word in words]

TypeScript Code (app.ts):

import { PyBridge } from 'pybridge';

const bridge = new PyBridge({ python: 'python3', cwd: __dirname });

interface API {
    word_sizes(words: string[]): number[];

const api = bridge.controller<API>('');
const sizes = await api.word_sizes(['hello', 'world']);

console.log(sizes); // Output: [5, 5]


In this example, we import the PyBridge library in TypeScript and create a PyBridge instance with the appropriate Python executable and current working directory. We define an interface (API) representing the Python functions we want to call. By creating a controller (api) using the PyBridge instance and the Python script filename, we can invoke the Python function word_sizes and retrieve the result in Node.js.


The importance of correctly mirroring the function signature of Python functions in TypeScript types when using PyBridge cannot be overstated. It ensures proper communication and data exchange between the Node.js and Python environments, preventing potential errors and inconsistencies.

Let's explore why this is crucial:

  • Type Safety: TypeScript is a statically-typed language that provides compile-time type checking. By accurately defining the types of the Python functions in TypeScript, you enable the TypeScript compiler to catch type-related errors before runtime. This significantly reduces the risk of encountering unexpected data types or mismatches between the two languages.

  • Data Serialization: PyBridge automatically serializes and deserializes data between Node.js and Python. For this process to work seamlessly, the data structures and types used in the function signatures must align correctly. When the TypeScript types accurately mirror the Python function signatures, PyBridge can serialize the data appropriately, ensuring compatibility between the two environments.

  • Parameter Validation: The function signatures defined in TypeScript serve as a contract for the expected parameters and return types of the Python functions. By matching the signature in TypeScript, you can validate the input parameters passed from Node.js and handle any errors or inconsistencies proactively. This helps maintain the integrity and reliability of the integration.

  • Documentation and Code Maintainability: Accurate function signatures in TypeScript act as self-documenting code. When developers refer to the TypeScript types, they gain insights into the expected inputs and outputs of the Python functions without having to examine the actual Python code. This improves code maintainability, as developers can understand the integration points and requirements more easily.

  • IDE Support: TypeScript's strong typing enables powerful IDE features like autocompletion, type inference, and code navigation. When the function signatures are correctly mirrored in TypeScript, developers can benefit from enhanced tooling support, making their development experience more efficient and error-free.

  • Runtime Types: PyBridge leverages the capabilities of Deepkit's Type-Compiler, which enables TypeScript types to be available in runtime. This integration allows for automatic and high-performance validation and serialization of data between Node.js and Python. By utilizing Deepkit's Type-Compiler, PyBridge ensures that the TypeScript types defined for Python functions are not only used for compile-time checks but also for runtime validation and serialization. This further enhances the reliability and efficiency of the data exchange process, ensuring seamless integration between the two environments while maintaining optimal performance.

In summary, mirroring the function signature of Python functions accurately in TypeScript types when using PyBridge ensures type safety, proper data serialization, parameter validation, code maintainability, and improved IDE support. It establishes a solid foundation for seamless and reliable integration between Node.js and Python.


PyBridge is a powerful TypeScript library that simplifies the integration of Python functions into Node.js applications. It provides a seamless and type-safe approach, allowing developers to harness the capabilities of Python, particularly in the context of machine learning models. With PyBridge, you can unlock new possibilities for your Node.js applications and enhance their functionality.