# DeerFlow Licensing Information: MIT License Terms and Usage Guide

> Explore DeerFlow licensing terms under the MIT License. Learn about commercial use, modification, and distribution guidelines for this permissive open-source project.

- Repository: [Bytedance Inc./deer-flow](https://github.com/bytedance/deer-flow)
- Tags: licensing-information
- Published: 2026-03-08

---

**DeerFlow is released under the MIT License, a permissive open-source license that allows commercial use, modification, and distribution provided the original copyright notice is preserved.**

This guide explains the licensing structure of the [bytedance/deer-flow](https://github.com/bytedance/deer-flow) repository, covering how the MIT License applies to the core engine, individual skills, and third-party dependencies. Understanding DeerFlow licensing information ensures compliance whether you are deploying the framework internally or distributing modified versions.

## Understanding the DeerFlow MIT License

The repository root contains the full license text in the [`LICENSE`](https://github.com/bytedance/deer-flow/blob/main/LICENSE) file. The copyright holders are **Bytedance Ltd. and/or its affiliates** and the **DeerFlow Authors**, dated 2025 and 2025-2026 respectively.

As a permissive license, the MIT License grants you the rights to use, copy, modify, merge, publish, distribute, sublicense, and sell copies of the software. The only requirement is that you include the original copyright notice and license terms in all copies or substantial portions of the software.

## License Scope and Coverage

The DeerFlow project applies licensing at multiple levels: the core engine, individual skills, and bundled dependencies.

### Core Engine

The entire backend, frontend, and supporting scripts located in the repository are uniformly covered by the MIT License. This includes the FastAPI gateway implementation in [`backend/src/gateway/app.py`](https://github.com/bytedance/deer-flow/blob/main/backend/src/gateway/app.py) and the embedded client in [`backend/src/client.py`](https://github.com/bytedance/deer-flow/blob/main/backend/src/client.py).

### Skills and Extensions

Individual skills within the project define their own licensing terms through a `license` field in their [`SKILL.md`](https://github.com/bytedance/deer-flow/blob/main/SKILL.md) front-matter. Many built-in skills (located under `skills/public/**/SKILL.md`) are also MIT-licensed, but you must verify each skill's metadata before use.

The skill loader parses this metadata and exposes it via the **Skills API** (`GET /api/skills`), allowing programmatic discovery of licensing terms for any installed component.

### Third-Party Dependencies

DeerFlow relies on external libraries such as LangChain, LangGraph, and FastAPI. These dependencies retain their original licenses as listed in `uv.lock` and [`package-lock.json`](https://github.com/bytedance/deer-flow/blob/main/package-lock.json) files. DeerFlow does not re-license these components; you must comply with the terms specified by each upstream package.

## How to Access Licensing Information Programmatically

You can retrieve DeerFlow licensing information through multiple interfaces depending on your integration needs.

### Reading the Repository License File

To access the full MIT license text directly from the filesystem, use the following Python function:

```python
from pathlib import Path

def get_deerflow_license() -> str:
    """Return the content of the DeerFlow LICENSE file."""
    license_path = Path(__file__).parent.parent / "LICENSE"
    return license_path.read_text(encoding="utf-8")

print(get_deerflow_license())

```

This script reads the `LICENSE` file from the repository root and outputs the complete license text including copyright notices.

### Querying Skill Licenses via the Client

The **DeerFlowClient** provides a Pythonic interface to inspect skill metadata, including licensing information:

```python
from src.client import DeerFlowClient

client = DeerFlowClient()

# List all installed skills with licensing details

skills = client.list_skills(enabled_only=False)

for skill in skills["skills"]:
    print(f"{skill['name']}: {skill['license']}")

```

The `list_skills()` method calls the backend `GET /api/skills` endpoint defined in [`backend/src/gateway/app.py`](https://github.com/bytedance/deer-flow/blob/main/backend/src/gateway/app.py). Each skill object in the response contains a `license` field that mirrors the value specified in its respective [`SKILL.md`](https://github.com/bytedance/deer-flow/blob/main/SKILL.md) file.

### Using the REST API Gateway

For external applications or shell scripts, query the Gateway API directly to retrieve specific skill licenses:

```bash
curl -s http://localhost:8001/api/skills | jq '.skills[] | select(.name=="pdf-processing") | .license'

# → "MIT"

```

This cURL command retrieves the license for the `pdf-processing` skill by filtering the JSON response from the `/api/skills` endpoint.

## Summary

- DeerFlow is licensed under the **MIT License**, permitting commercial and private use with minimal restrictions.
- The core engine, client libraries, and gateway are all covered by the same MIT terms stored in the root `LICENSE` file.
- Individual skills may specify different licenses through the `license` field in their [`SKILL.md`](https://github.com/bytedance/deer-flow/blob/main/SKILL.md) front-matter, accessible via the Skills API (`GET /api/skills`).
- Third-party dependencies maintain their original licenses as defined in `uv.lock` and [`package-lock.json`](https://github.com/bytedance/deer-flow/blob/main/package-lock.json); compliance with these terms remains your responsibility.

## Frequently Asked Questions

### Is DeerFlow free for commercial use?

Yes. The MIT License explicitly permits commercial use, including selling copies of the software. You may use DeerFlow in proprietary applications and products provided you include the original copyright notice and license text from the `LICENSE` file.

### Where can I find the full license text?

The complete license text resides in the [`LICENSE`](https://github.com/bytedance/deer-flow/blob/main/LICENSE) file at the repository root. You can read it directly from the filesystem or retrieve it programmatically using standard file I/O operations as shown in the code examples above.

### Do individual skills have different licenses?

Yes, individual skills can define their own licensing terms. Each skill's [`SKILL.md`](https://github.com/bytedance/deer-flow/blob/main/SKILL.md) file includes a `license` field in its front-matter that specifies the governing license (e.g., MIT, Apache-2.0). You can query these terms through the DeerFlowClient's `list_skills()` method or via the REST API endpoint `GET /api/skills`.

### How do third-party dependencies affect licensing?

DeerFlow bundles numerous third-party libraries (LangChain, FastAPI, etc.) that retain their original licenses as recorded in `uv.lock` and [`package-lock.json`](https://github.com/bytedance/deer-flow/blob/main/package-lock.json). These components are not re-licensed under DeerFlow's MIT terms. You must review and comply with each dependency's specific license requirements when distributing DeerFlow applications.