DeerFlow Licensing Information: MIT License Terms and Usage Guide

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 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 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 and the embedded client in 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 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 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:

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:

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. Each skill object in the response contains a license field that mirrors the value specified in its respective SKILL.md file.

Using the REST API Gateway

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

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 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; 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 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 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. 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}