# Devolens / Cryptolens

```json
{
  "name": "Devolens / Cryptolens",
  "slug": "devolens",
  "url": "https://composio.dev/toolkits/devolens",
  "markdown_url": "https://composio.dev/toolkits/devolens.md",
  "logo_url": "https://logos.composio.dev/api/devolens",
  "categories": [
    "developer tools & devops"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-08-20T15:31:33.927Z"
}
```

![Devolens / Cryptolens logo](https://logos.composio.dev/api/devolens)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Devolens / Cryptolens MCP or direct API to manage products, create license keys, query customers, and inspect entitlements through natural language.

## Summary

Devolens provides the Cryptolens API for software licensing, license keys, products, customers, entitlements, and usage analytics.
Use it to automate license lifecycle management and protect paid software without building a licensing backend.

## Categories

- developer tools & devops

## Toolkit Details

- Tools: 10

## Images

- Logo: https://logos.composio.dev/api/devolens

## Authentication

- **Api Key**
  - Type: `api_key`
  - Description: Api Key authentication for Devolens / Cryptolens.
  - Setup:
    - Configure Api Key credentials for Devolens / Cryptolens.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- List expired Cryptolens license keys
- Create license key for enterprise customer
- Show usage analytics for active products

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `DEVOLENS_GET_LICENSE_KEY` | Get License Key | Retrieve one license key and optional activation metadata by its product ID and key string. The token must enable the Get Key method. |
| `DEVOLENS_LIST_CUSTOMERS` | List Customers | Search or list customers visible to the connected Cryptolens account, including reseller-visible customer groups returned by the API. The token must enable the Get Customers method. |
| `DEVOLENS_LIST_DAILY_USAGE_AGGREGATES` | List Daily Usage Aggregates | Return one page of daily Cryptolens usage aggregates, optionally filtered by product and inclusive date range. Pass next_cursor back with the same filters to continue forward. The token must enable the Usage Analytics method group. |
| `DEVOLENS_LIST_LICENSE_KEYS` | List License Keys | List and search one page of license keys for a Cryptolens product. Call List Products first when the product ID is unknown, then pass next_cursor back to continue through additional pages. The token must enable the Get Keys method. |
| `DEVOLENS_LIST_LICENSE_TEMPLATES` | List License Templates | Return the license templates available to the connected Cryptolens account. The token must enable the Get License Templates method. |
| `DEVOLENS_LIST_LICENSE_USERS` | List License Users | Return registered Cryptolens license users, optionally limited to one customer. The token must enable the UserAuthAdmin method group. |
| `DEVOLENS_LIST_MESSAGES` | List Messages | Return Cryptolens account messages, optionally filtered by channel or creation time. The token must enable the Get Messages method. |
| `DEVOLENS_LIST_PRODUCTS` | List Products | Return the Cryptolens products visible to the connected access token. Use this first to obtain product IDs required by license-key tools. The token must enable the Get Products method. |
| `DEVOLENS_LIST_RESELLERS` | List Resellers | Search or list resellers visible to the connected Cryptolens account. The token must enable the Reseller method group. |
| `DEVOLENS_LIST_WEB_API_LOGS` | List Web API Logs | Inspect one page of Cryptolens Web API request logs with optional product, license-key, machine, event, and time filters. Pass next_cursor back to continue when one is returned. The token must enable the Get Web APILog method. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK
```python
pip install composio_openai
```

```typescript
npm install @composio/openai
```

#### Path 1, Step 2: Initialize Composio and Create Tool Router Session

Import and initialize Composio client, then create a Tool Router session
```python
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
openai = OpenAI()
session = composio.create(user_id='your-user-id')
```

```typescript
import OpenAI from 'openai';
import { Composio } from '@composio/core';
import { OpenAIResponsesProvider } from '@composio/openai';

const composio = new Composio({
  provider: new OpenAIResponsesProvider(),
});
const openai = new OpenAI({});
const session = await composio.create('your-user-id');
```

#### Path 1, Step 3: Execute Devolens / Cryptolens Tools via Tool Router with Your Agent

Get tools from Tool Router session and execute Devolens / Cryptolens actions with your Agent
```python
tools = session.tools
response = openai.responses.create(
  model='gpt-4.1',
  tools=tools,
  input=[{
    'role': 'user',
    'content': 'List all active Cryptolens license keys for my main product'
  }]
)
result = composio.provider.handle_tool_calls(
  response=response,
  user_id='your-user-id'
)
print(result)
```

```typescript
const tools = session.tools;
const response = await openai.responses.create({
  model: 'gpt-4.1',
  tools: tools,
  input: [{
    role: 'user',
    content: 'List all active Cryptolens license keys for my main product'
  }],
});
const result = await composio.provider.handleToolCalls(
  'your-user-id',
  response.output
);
console.log(result);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK for Python or TypeScript
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/openai @ai-sdk/mcp
```

#### Path 2, Step 2: Initialize Client and Create Tool Router Session

Import and initialize the Composio client, then create a Tool Router session for Devolens / Cryptolens
```python
from composio import Composio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

composio = Composio(api_key='your-composio-api-key')
session = composio.create(user_id='your-user-id')
url = session.mcp.url
```

```typescript
import { Composio } from '@composio/core';

const composio = new Composio({ apiKey: 'your-api-key' });
const session = await composio.create('your-user-id');
console.log(`Tool Router session created: ${session.mcp.url}`);
```

#### Path 2, Step 3: Connect to AI Agent

Use the MCP server with your AI agent (Anthropic Claude or Mastra)
```python
import asyncio

options = ClaudeAgentOptions(
    permission_mode='bypassPermissions',
    mcp_servers={
        'tool_router': {
            'type': 'http',
            'url': url,
            'headers': {
                'x-api-key': 'your-composio-api-key'
            }
        }
    },
    system_prompt='You are a helpful assistant with access to Devolens / Cryptolens tools.',
    max_turns=10
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query('Find customers with expired Cryptolens license keys')
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { openai } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText } from 'ai';

const client = await createMCPClient({
  transport: {
    type: 'http',
    url: session.mcp.url,
    headers: {
      'x-api-key': 'your-composio-api-key',
    },
  },
});

const tools = await client.tools();
const { text } = await generateText({
  model: openai('gpt-4o'),
  tools,
  messages: [{
    role: 'user',
    content: 'Find customers with expired Cryptolens license keys'
  }],
  maxSteps: 5,
});

console.log(`Agent: ${text}`);
```

## Why Use Composio?

### 1. AI Native Devolens / Cryptolens Integration

- Supports both Devolens / Cryptolens MCP and direct API based integrations
- Structured, LLM-friendly schemas help agents manage license keys, products, customers, and entitlements with fewer mistakes
- Rich coverage for reading, writing, and querying your Cryptolens licensing data without custom integration code

### 2. Managed Auth

- Secure API key handling so you don't hard-code Cryptolens credentials inside prompts, agents, or app code
- Central place to manage, scope, and revoke Devolens / Cryptolens access across users and environments
- Per user and per environment credentials for safer production licensing workflows

### 3. Agent Optimized Design

- Tools are shaped for real agent tasks like checking license status, finding customers, and updating product entitlements
- Execution logs show what ran, when it ran, and on whose behalf, which is useful when agents touch licensing data
- Clear tool inputs and outputs make it easier for LLMs to take the right licensing action the first time

### 4. Enterprise Grade Security

- Fine-grained RBAC lets you control which agents and users can access Devolens / Cryptolens
- Scoped, least privilege access helps protect sensitive license, customer, and product data
- Full audit trail of agent actions supports internal review, compliance, and incident checks

## Use Devolens / Cryptolens with any AI Agent Framework

Choose a framework you want to connect Devolens / Cryptolens with:

None listed.

## Related Toolkits

- [Supabase](https://composio.dev/toolkits/supabase) - Supabase is an open-source backend platform offering scalable Postgres databases, authentication, storage, and real-time APIs. It lets developers build modern apps without managing infrastructure.
- [Codeinterpreter](https://composio.dev/toolkits/codeinterpreter) - Codeinterpreter is a Python-based coding environment with built-in data analysis and visualization. It lets you instantly run scripts, plot results, and prototype solutions inside supported platforms.
- [GitHub](https://composio.dev/toolkits/github) - GitHub is a code hosting platform for version control and collaborative software development. It streamlines project management, code review, and team workflows in one place.
- [1password](https://composio.dev/toolkits/_1password) - 1Password is a password manager and digital vault for storing logins, secrets, notes, and secure documents. It helps individuals and teams protect credentials, share access safely, and reduce password risk.
- [Ably](https://composio.dev/toolkits/ably) - Ably is a real-time messaging platform for live chat and data sync in modern apps. It offers global scale and rock-solid reliability for seamless, instant experiences.
- [Abuselpdb](https://composio.dev/toolkits/abuselpdb) - Abuselpdb is a central database for reporting and checking IPs linked to malicious online activity. Use it to quickly identify and report suspicious or abusive IP addresses.
- [Alchemy](https://composio.dev/toolkits/alchemy) - Alchemy is a blockchain development platform offering APIs and tools for Ethereum apps. It simplifies building and scaling Web3 projects with robust infrastructure.
- [Algolia](https://composio.dev/toolkits/algolia) - Algolia is a hosted search API that powers lightning-fast, relevant search experiences for web and mobile apps. It helps developers deliver instant, typo-tolerant, and scalable search without complex infrastructure.
- [Anchor browser](https://composio.dev/toolkits/anchor_browser) - Anchor browser is a developer platform for AI-powered web automation. It transforms complex browser actions into easy API endpoints for streamlined web interaction.
- [Apiflash](https://composio.dev/toolkits/apiflash) - Apiflash is a website screenshot API for programmatically capturing web pages. It delivers high-quality screenshots on demand for automation, monitoring, or reporting.
- [Apiverve](https://composio.dev/toolkits/apiverve) - Apiverve delivers a suite of powerful APIs that simplify integration for developers. It's designed for reliability and scalability so you can build faster, smarter applications without the integration headache.
- [Appcircle](https://composio.dev/toolkits/appcircle) - Appcircle is an enterprise-grade mobile CI/CD platform for building, testing, and publishing mobile apps. It streamlines mobile DevOps so teams ship faster and with more confidence.
- [Appdrag](https://composio.dev/toolkits/appdrag) - Appdrag is a cloud platform for building websites, APIs, and databases with drag-and-drop tools and code editing. It accelerates development and iteration by combining hosting, database management, and low-code features in one place.
- [Appveyor](https://composio.dev/toolkits/appveyor) - AppVeyor is a cloud-based continuous integration service for building, testing, and deploying applications. It helps developers automate and streamline their software delivery pipelines.
- [AWS Marketplace MCP](https://composio.dev/toolkits/aws_marketplace_mcp) - AWS Marketplace MCP provides MCP access to AWS Marketplace's cloud software, data, and services catalog. Use it to discover, compare, and evaluate 30K+ AWS Marketplace listings faster.
- [Backendless](https://composio.dev/toolkits/backendless) - Backendless is a backend-as-a-service platform for mobile and web apps, offering database, file storage, user authentication, and APIs. It helps developers ship scalable applications faster without managing server infrastructure.
- [Baserow](https://composio.dev/toolkits/baserow) - Baserow is an open-source no-code database platform for building collaborative data apps. It makes it easy for teams to organize data and automate workflows without writing code.
- [Bench](https://composio.dev/toolkits/bench) - Bench is a benchmarking tool for automated performance measurement and analysis. It helps you quickly evaluate, compare, and track your systems or workflows.
- [Better stack](https://composio.dev/toolkits/better_stack) - Better Stack is a monitoring, logging, and incident management solution for apps and services. It helps teams ensure application reliability and performance with real-time insights.
- [Bitbucket](https://composio.dev/toolkits/bitbucket) - Bitbucket is a Git-based code hosting and collaboration platform for teams. It enables secure repository management and streamlined code reviews.

## Frequently Asked Questions

### Do I need my own developer credentials to use Devolens / Cryptolens with Composio?

Yes, Devolens / Cryptolens requires you to configure your own API key credentials. Once set up, Composio handles secure credential storage and API request handling for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)