# LayerCall [Health: Active]

**Category:** 💬 Communication  
**Repository:** https://github.com/LayerCall/layercall-sdk  
**GitHub Stars:** 0  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/layercall

## Description
Score an IP, email, phone, domain or device for fraud in one call, with the signals behind it.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "layercall": {
    "command": "npx",
    "args": ["-y","layercall"],
    "env": {
      "LAYERCALL_API_KEY": ""
    }
  }
}
```

**Requires environment variables:** `LAYERCALL_API_KEY` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What LayerCall MCP server does

LayerCall MCP server gives compatible AI clients access to LayerCall’s fraud and trust checks without requiring a local MCP process. The service is hosted at `https://www.layercall.com/api/mcp` and communicates over Streamable HTTP. Requests are authenticated with an API key sent as a bearer token.

The checks cover individual identity and network attributes as well as combined signup data. An agent can assess an IP address, validate an email, inspect a phone number, score a domain, evaluate a device, verify an AI agent, or submit a combined user check. Results use a common structure centered on a numeric risk score from 0 to 100 and one of three decisions: `allow`, `review`, or `block`.

The response can also include the signals that influenced the result. Depending on the lookup, these may include VPN, proxy, Tor, datacenter, abuse, email, domain, phone, device, geographic, or agent-authentication information.

## How it works

Configure an MCP client with the remote endpoint and an `Authorization` header containing the LayerCall API key. There is no local package to install for MCP use. Claude Code, Claude Desktop, ChatGPT, Cursor, VS Code, Windsurf, and Zed are listed as clients that can connect to the service. VS Code uses `servers` as its top-level configuration key, while the other example configuration uses `mcpServers`.

LayerCall MCP server exposes these seven tools:

- `score_ip`
- `verify_email`
- `lookup_phone`
- `score_domain`
- `score_device`
- `verify_agent`
- `score_user`

The combined user check is intended for signup-related decisions, while the individual tools support narrower investigations. A client can therefore ask for a single signal, such as domain or IP reputation, or provide several user attributes for one weighted verdict.

Use the `review` result as a distinct outcome rather than treating every non-allow response as a rejection. The documentation describes it as suitable for additional verification or manual review. Also preserve unknown values as unknown: a `null` field does not establish that the corresponding risk signal is absent.

## Setup and configuration

Create a LayerCall API key and add the remote server to the MCP client configuration. The documented endpoint is:

```json
{
  "mcpServers": {
    "layercall": {
      "url": "https://www.layercall.com/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}
```

The service offers a free API key with 1,000 lookups per month and no card requirement. Test-mode keys return deterministic synthetic values using reserved test data, including documentation-backed fixtures. They are intended for assertions and do not consume live reputation data or write to the shared reputation network.

LayerCall MCP server is separate from the repository’s Node, Python, and CLI SDK usage. Those SDKs can be installed independently, but MCP clients should use the hosted HTTP endpoint and header configuration instead of running one of those packages locally.

## Limitations and notes

The available MCP tools do not include the repository’s batch endpoint, Express middleware, or Next.js helpers. The README lists a batch API separately for up to 500 values of one type, but it is not among the seven MCP tools.

Returned information depends on the lookup type and available source data. For example, domain registration age can be unknown when a top-level domain does not publish RDAP data, and mailbox existence can be unknown when a mail provider does not provide a reliable response. Integrations should handle these `null` values explicitly.

The repository is MIT licensed. The MCP interface requires an API key, so it is not an unauthenticated local server.

_Full upstream README: https://allmcps.com/mcp/layercall/readme_