# LicenseCheck API MCP MCP

> LicenseCheck API MCP lets your AI agent query a massive database of software licenses to check permissions, conditions, and limitations. Instead of manually reading legal text for every dependency, you ask your agent what a specific license allows. It pulls the exact metadata you need to keep your project compliant without opening a single legal portal.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** license-auditing, open-source-compliance, software-licensing, legal-tech, risk-management, api-integration

## Description

You pull in a new open-source dependency. Before you merge, you need to know if its license plays nice with your commercial product. Usually, this means opening a new tab, finding the legal text, and trying to decipher what copyleft actually means for your specific use case. This MCP changes that. You just ask your AI client if the license allows commercial distribution or requires source code disclosure. It checks the exact legal metadata and gives you a straight answer.

Instead of playing lawyer every time you add a package, you treat compliance like a quick chat. You can ask about specific conditions, check what is strictly prohibited, or just get a full list of known licenses to audit your current stack. Since it connects through Vinkius, you do not have to manage separate API keys or deal with messy authentication setups for every different legal database. Your agent just handles the lookups in the background while you focus on writing code. It turns a tedious, error-prone manual review into a simple question and answer session. You get the exact legal boundaries of your dependencies without ever leaving your terminal.

## Tools

### check_api_status
Checks if the LicenseCheck database is online and responding to requests.

### check_software_license
Searches for a specific software license by its name or identifier.

### get_license_details
Pulls the full legal metadata, permissions, and conditions for a specific license ID.

### list_all_licenses
Returns a complete list of every software license currently stored in the database.

## Prompt Examples

**Prompt:** 
```
Check the software license 'MIT' using LicenseCheck.
```

**Response:** 
```
I've retrieved the details for the MIT license! It is a short and permissive license that allows for commercial use, distribution, and modification. Notable conditions include including the copyright notice. Would you like the full legal metadata?
```

**Prompt:** 
```
What are the limitations of the 'GPL-3.0' license?
```

**Response:** 
```
I've identified the limitations for GPL-3.0. It is a copyleft license that requires derivatives to be licensed under the same terms. Notable limitations include liability and warranty disclaimers. I can provide the full list of conditions if you'd like.
```

**Prompt:** 
```
List all software licenses available in the database.
```

**Response:** 
```
I've scanned the license catalog from LicenseCheck! There are hundreds of licenses listed, from common open-source ones to specialized proprietary models. I can assist you with a keyword search to identify the exact markers for your audit.
```

## Capabilities

### Check license permissions
See exactly what a specific license allows you to do with the code.

### Query license conditions
Find out what you must do to stay compliant, like including copyright notices.

### Identify legal limitations
Spot strict prohibitions and risk markers before they break your deployment.

### Pull full license metadata
Get the complete legal details and version history for any known software license.

### Audit your entire stack
List every license in the database to cross-reference against your project dependencies.

### Monitor API health
Verify the legal database is online and responding before you run a massive compliance audit.

## Use Cases

### The Friday afternoon merge panic
A developer wants to merge a new library but isn't sure if the license allows commercial use. They ask their agent to check_software_license, and it instantly confirms the permissions without halting the release.

### The annual compliance audit
A legal team needs to verify every open-source package in the company's main product. An ops lead uses list_all_licenses to get the full database, then queries get_license_details for each dependency to build a risk report.

### The copyleft contamination scare
An architect notices a GPL dependency in a proprietary microservice. They ask the agent to get_license_details, which pulls the exact conditions and confirms whether the specific version triggers the viral open-source requirement.

### The pre-deployment health check
A CI pipeline needs to verify license terms before building a Docker image. The pipeline script runs check_api_status first to ensure the legal database is up, then queries the specific licenses to block the build if restrictions are violated.

## Benefits

- Stop guessing what a license allows. When you use get_license_details, your agent pulls the exact permissions and conditions so you know if commercial use is actually allowed.
- Catch copyleft contamination early. Ask your agent to check_software_license before merging, and it will flag strict requirements that could force you to open-source your proprietary code.
- Audit your entire dependency tree in minutes. Use list_all_licenses to pull the full catalog, then cross-reference it against your package manager to spot risky libraries.
- Know exactly what you must do to comply. Instead of reading dense legal text, your agent extracts the mandatory conditions so you know exactly which copyright notices to include.
- Never let a downed database block your audit. Run check_api_status to verify the legal data source is healthy before you start a massive compliance review.

## How It Works

The bottom line is you get instant, accurate legal context for any software license without leaving your coding environment.

1. Add the LicenseCheck MCP to your AI client and paste in your API key from LicenseAPI.dev.
2. Ask your agent to check the terms of a specific dependency or audit your current package list.
3. Read the plain-English breakdown of permissions, conditions, and restrictions your agent pulls back.

## Frequently Asked Questions

**Does LicenseCheck API MCP work with proprietary licenses?**
Yes, it includes both open-source and proprietary license data. You can search for specific proprietary terms just like you would for MIT or GPL.

**How do I know if LicenseCheck API is down before I run an audit?**
Use the check_api_status tool. It pings the service and confirms it is operational before you start pulling heavy license data.

**Can I use LicenseCheck API MCP to revoke a compromised license key?**
No, this is a read-only legal database. It tells you what a license allows, but it does not manage or revoke active software keys in your application.

**What happens if check_software_license returns no results?**
It means that specific license identifier is not in the database. Use list_all_licenses to see the exact names and formats the database currently supports.

**Does LicenseCheck API MCP tell me if a license is compatible with my project?**
It gives you the exact permissions and conditions. Your AI client uses that data to tell you if it is compatible, but the MCP itself just provides the raw legal facts.

**How do I authenticate my LicenseCheck API MCP connection?**
You need a LicenseCheck API key. Paste it into the environment variables when you subscribe to this MCP on Vinkius. The agent uses it automatically for every request.

**Will list_all_licenses crash my agent if the database is huge?**
No, it just returns the raw catalog array. The API handles the heavy lifting on their end. Your agent processes the text output, so memory limits depend on your client, not this MCP.

**What error does get_license_details throw if I pass a bad license ID?**
It returns a standard HTTP 404 not found error. The tool passes the exact API response back to your agent so it knows the ID was invalid instead of making up fake legal metadata.