> ## Documentation Index
> Fetch the complete documentation index at: https://core.anylayer.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Trust Modules

> Get available trust modules and schemas

## Overview

Retrieve all available trust modules, schemas, and their configurations. This endpoint provides comprehensive information about the trust system's capabilities, making it perfect for building trust-based applications and understanding available attestation types.

<Tip>
  Use this endpoint to discover available trust modules, understand attestation schemas, and build applications that leverage the trust system's capabilities.
</Tip>

## Parameters

<ParamField query="type" type="string">
  Filter by module type

  * `schema` - Attestation schemas
  * `evaluator` - Policy evaluators
  * `verifier` - Attestation verifiers
  * `scorer` - Trust scorers
  * `all` - All modules (default)
</ParamField>

<ParamField query="category" type="string">
  Filter by module category

  * `identity` - Identity-related modules
  * `skill` - Skill-related modules
  * `relationship` - Relationship modules
  * `achievement` - Achievement modules
  * `reputation` - Reputation modules
  * `custom` - Custom modules
</ParamField>

<ParamField query="status" type="string">
  Filter by module status

  * `active` - Active modules (default)
  * `deprecated` - Deprecated modules
  * `beta` - Beta modules
  * `all` - All modules
</ParamField>

<ParamField query="version" type="string">
  Filter by module version
</ParamField>

<ParamField query="limit" type="number">
  Number of modules to return (default: 50, max: 100)
</ParamField>

<ParamField query="offset" type="number">
  Number of modules to skip for pagination (default: 0)
</ParamField>

<ParamField query="includeDetails" type="boolean">
  Include detailed module information (default: true)
</ParamField>

<ParamField query="includeExamples" type="boolean">
  Include usage examples (default: true)
</ParamField>

## Response

<ResponseField name="success" type="boolean">
  Indicates if the request was successful
</ResponseField>

<ResponseField name="modules" type="array">
  Array of trust modules

  <Expandable title="module properties">
    <ResponseField name="id" type="string">
      Module identifier
    </ResponseField>

    <ResponseField name="name" type="string">
      Module name
    </ResponseField>

    <ResponseField name="description" type="string">
      Module description
    </ResponseField>

    <ResponseField name="type" type="string">
      Module type (schema, evaluator, verifier, scorer)
    </ResponseField>

    <ResponseField name="category" type="string">
      Module category
    </ResponseField>

    <ResponseField name="version" type="string">
      Module version
    </ResponseField>

    <ResponseField name="status" type="string">
      Module status (active, deprecated, beta)
    </ResponseField>

    <ResponseField name="schema" type="object">
      Module schema definition

      <Expandable title="schema properties">
        <ResponseField name="fields" type="array">
          Schema fields

          <Expandable title="field properties">
            <ResponseField name="name" type="string">
              Field name
            </ResponseField>

            <ResponseField name="type" type="string">
              Field type
            </ResponseField>

            <ResponseField name="required" type="boolean">
              Whether field is required
            </ResponseField>

            <ResponseField name="description" type="string">
              Field description
            </ResponseField>

            <ResponseField name="validation" type="object">
              Field validation rules
            </ResponseField>
          </Expandable>
        </ResponseField>

        <ResponseField name="validation" type="object">
          Schema validation rules
        </ResponseField>

        <ResponseField name="examples" type="array">
          Schema examples
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="configuration" type="object">
      Module configuration

      <Expandable title="configuration properties">
        <ResponseField name="enabled" type="boolean">
          Whether module is enabled
        </ResponseField>

        <ResponseField name="settings" type="object">
          Module settings
        </ResponseField>

        <ResponseField name="permissions" type="array">
          Required permissions
        </ResponseField>

        <ResponseField name="dependencies" type="array">
          Module dependencies
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="capabilities" type="array">
      Module capabilities
    </ResponseField>

    <ResponseField name="examples" type="array">
      Usage examples

      <Expandable title="example properties">
        <ResponseField name="title" type="string">
          Example title
        </ResponseField>

        <ResponseField name="description" type="string">
          Example description
        </ResponseField>

        <ResponseField name="code" type="string">
          Example code
        </ResponseField>

        <ResponseField name="language" type="string">
          Example language
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="documentation" type="object">
      Module documentation

      <Expandable title="documentation properties">
        <ResponseField name="overview" type="string">
          Module overview
        </ResponseField>

        <ResponseField name="usage" type="string">
          Usage instructions
        </ResponseField>

        <ResponseField name="api" type="string">
          API documentation
        </ResponseField>

        <ResponseField name="troubleshooting" type="string">
          Troubleshooting guide
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="createdAt" type="string">
      ISO 8601 timestamp of module creation
    </ResponseField>

    <ResponseField name="updatedAt" type="string">
      ISO 8601 timestamp of last update
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="pagination" type="object">
  Pagination information

  <Expandable title="pagination properties">
    <ResponseField name="total" type="number">
      Total number of modules
    </ResponseField>

    <ResponseField name="limit" type="number">
      Number of modules returned
    </ResponseField>

    <ResponseField name="offset" type="number">
      Current offset
    </ResponseField>

    <ResponseField name="hasMore" type="boolean">
      Whether more modules are available
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="summary" type="object">
  Module summary statistics

  <Expandable title="summary properties">
    <ResponseField name="totalModules" type="number">
      Total number of modules
    </ResponseField>

    <ResponseField name="activeModules" type="number">
      Number of active modules
    </ResponseField>

    <ResponseField name="deprecatedModules" type="number">
      Number of deprecated modules
    </ResponseField>

    <ResponseField name="betaModules" type="number">
      Number of beta modules
    </ResponseField>

    <ResponseField name="typeBreakdown" type="object">
      Breakdown by module type
    </ResponseField>

    <ResponseField name="categoryBreakdown" type="object">
      Breakdown by module category
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="timestamp" type="string">
  ISO 8601 timestamp of the response
</ResponseField>

## Examples

<CodeGroup>
  ```bash cURL (All Modules) theme={null}
  curl "https://api.onzks.com/v1/trust/modules" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```bash cURL (Schema Modules Only) theme={null}
  curl "https://api.onzks.com/v1/trust/modules?type=schema&status=active" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```bash cURL (Skill Category) theme={null}
  curl "https://api.onzks.com/v1/trust/modules?category=skill&includeDetails=true" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```bash cURL (With Examples) theme={null}
  curl "https://api.onzks.com/v1/trust/modules?includeExamples=true&limit=20" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```javascript JavaScript theme={null}
  async function getTrustModules(options = {}) {
    const {
      type = 'all',
      category,
      status = 'active',
      version,
      limit = 50,
      offset = 0,
      includeDetails = true,
      includeExamples = true
    } = options;

    const params = new URLSearchParams({
      type,
      status,
      limit: limit.toString(),
      offset: offset.toString(),
      includeDetails: includeDetails.toString(),
      includeExamples: includeExamples.toString()
    });

    if (category) params.append('category', category);
    if (version) params.append('version', version);

    const response = await fetch(
      `https://api.onzks.com/v1/trust/modules?${params}`,
      {
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY'
        }
      }
    );

    const data = await response.json();

    console.log(`Trust Modules (${data.summary.totalModules} total):`);
    console.log(`Active: ${data.summary.activeModules}`);
    console.log(`Beta: ${data.summary.betaModules}`);
    console.log(`Deprecated: ${data.summary.deprecatedModules}`);

    data.modules.forEach(module => {
      console.log(`- ${module.name} (${module.type}) - ${module.status}`);
    });

    return data;
  }

  // Usage examples
  await getTrustModules();
  await getTrustModules({ type: 'schema', status: 'active' });
  await getTrustModules({ category: 'skill', includeDetails: true });
  await getTrustModules({ includeExamples: true, limit: 20 });
  ```

  ```python Python theme={null}
  import requests

  def get_trust_modules(type='all', category=None, status='active', version=None,
                       limit=50, offset=0, include_details=True, include_examples=True):
      params = {
          'type': type,
          'status': status,
          'limit': limit,
          'offset': offset,
          'includeDetails': include_details,
          'includeExamples': include_examples
      }
      
      if category:
          params['category'] = category
      if version:
          params['version'] = version
      
      response = requests.get(
          'https://api.onzks.com/v1/trust/modules',
          headers={'Authorization': 'Bearer YOUR_API_KEY'},
          params=params
      )
      
      data = response.json()
      
      print(f"Trust Modules ({data['summary']['totalModules']} total):")
      print(f"Active: {data['summary']['activeModules']}")
      print(f"Beta: {data['summary']['betaModules']}")
      print(f"Deprecated: {data['summary']['deprecatedModules']}")
      
      for module in data['modules']:
          print(f"- {module['name']} ({module['type']}) - {module['status']}")
      
      return data

  # Usage examples
  get_trust_modules()
  get_trust_modules(type='schema', status='active')
  get_trust_modules(category='skill', include_details=True)
  get_trust_modules(include_examples=True, limit=20)
  ```
</CodeGroup>

## Response Example

```json theme={null}
{
  "success": true,
  "modules": [
    {
      "id": "skill_schema_v1",
      "name": "Skill Attestation Schema",
      "description": "Schema for skill and expertise attestations",
      "type": "schema",
      "category": "skill",
      "version": "1.0.0",
      "status": "active",
      "schema": {
        "fields": [
          {
            "name": "title",
            "type": "string",
            "required": true,
            "description": "Skill title",
            "validation": {
              "minLength": 1,
              "maxLength": 100
            }
          },
          {
            "name": "description",
            "type": "string",
            "required": true,
            "description": "Skill description",
            "validation": {
              "minLength": 10,
              "maxLength": 500
            }
          },
          {
            "name": "category",
            "type": "string",
            "required": true,
            "description": "Skill category",
            "validation": {
              "enum": ["programming", "design", "business", "blockchain", "other"]
            }
          },
          {
            "name": "value",
            "type": "string",
            "required": true,
            "description": "Skill level",
            "validation": {
              "enum": ["beginner", "intermediate", "advanced", "expert"]
            }
          },
          {
            "name": "metadata",
            "type": "object",
            "required": false,
            "description": "Additional metadata",
            "validation": {
              "properties": {
                "yearsExperience": {"type": "number", "minimum": 0},
                "projects": {"type": "array", "items": {"type": "string"}},
                "certifications": {"type": "array", "items": {"type": "string"}}
              }
            }
          },
          {
            "name": "evidence",
            "type": "array",
            "required": false,
            "description": "Supporting evidence",
            "validation": {
              "items": {
                "type": "object",
                "properties": {
                  "type": {"type": "string", "enum": ["url", "document", "transaction"]},
                  "value": {"type": "string"},
                  "description": {"type": "string"}
                }
              }
            }
          }
        ],
        "validation": {
          "required": ["title", "description", "category", "value"],
          "additionalProperties": false
        },
        "examples": [
          {
            "title": "Solidity Developer",
            "description": "Expert in smart contract development",
            "category": "programming",
            "value": "expert",
            "metadata": {
              "yearsExperience": 5,
              "projects": ["DeFi Protocol", "NFT Marketplace"],
              "certifications": ["Certified Solidity Developer"]
            },
            "evidence": [
              {
                "type": "url",
                "value": "https://github.com/user/solidity-projects",
                "description": "GitHub repository with Solidity projects"
              }
            ]
          }
        ]
      },
      "configuration": {
        "enabled": true,
        "settings": {
          "maxEvidenceItems": 10,
          "requireEvidence": false,
          "allowCustomFields": true
        },
        "permissions": ["create_attestation", "read_attestation"],
        "dependencies": ["identity_verification"]
      },
      "capabilities": [
        "skill_attestation",
        "evidence_validation",
        "trust_scoring",
        "reputation_building"
      ],
      "examples": [
        {
          "title": "Create Skill Attestation",
          "description": "Create a skill attestation for a developer",
          "code": "const attestation = await createAttestation({\n  subject: 'alice.zks',\n  schema: 'skill',\n  data: {\n    title: 'React Developer',\n    description: 'Expert in React and frontend development',\n    category: 'programming',\n    value: 'expert'\n  }\n});",
          "language": "javascript"
        }
      ],
      "documentation": {
        "overview": "The skill schema allows users to attest to their skills and expertise in various domains.",
        "usage": "Use this schema to create skill attestations that can be used for reputation building and trust scoring.",
        "api": "POST /v1/trust/attestations with schema: 'skill'",
        "troubleshooting": "Common issues include missing required fields and invalid evidence formats."
      },
      "createdAt": "2024-01-01T00:00:00Z",
      "updatedAt": "2024-01-15T10:30:00Z"
    },
    {
      "id": "relationship_schema_v1",
      "name": "Relationship Attestation Schema",
      "description": "Schema for relationship attestations",
      "type": "schema",
      "category": "relationship",
      "version": "1.0.0",
      "status": "active",
      "schema": {
        "fields": [
          {
            "name": "title",
            "type": "string",
            "required": true,
            "description": "Relationship title"
          },
          {
            "name": "description",
            "type": "string",
            "required": true,
            "description": "Relationship description"
          },
          {
            "name": "category",
            "type": "string",
            "required": true,
            "description": "Relationship category"
          },
          {
            "name": "value",
            "type": "string",
            "required": true,
            "description": "Trust level"
          }
        ],
        "validation": {
          "required": ["title", "description", "category", "value"]
        },
        "examples": [
          {
            "title": "Business Partner",
            "description": "Long-term business partnership",
            "category": "business",
            "value": "trusted"
          }
        ]
      },
      "configuration": {
        "enabled": true,
        "settings": {
          "maxRelationships": 100,
          "requireMutualConsent": true
        },
        "permissions": ["create_attestation", "read_attestation"],
        "dependencies": ["identity_verification"]
      },
      "capabilities": [
        "relationship_attestation",
        "mutual_consent",
        "trust_scoring"
      ],
      "examples": [
        {
          "title": "Create Relationship Attestation",
          "description": "Create a relationship attestation",
          "code": "const attestation = await createAttestation({\n  subject: 'bob.zks',\n  schema: 'relationship',\n  data: {\n    title: 'Business Partner',\n    description: 'Long-term business partnership',\n    category: 'business',\n    value: 'trusted'\n  }\n});",
          "language": "javascript"
        }
      ],
      "documentation": {
        "overview": "The relationship schema allows users to attest to their relationships with other users.",
        "usage": "Use this schema to create relationship attestations that can be used for trust scoring and reputation building.",
        "api": "POST /v1/trust/attestations with schema: 'relationship'",
        "troubleshooting": "Common issues include missing mutual consent and invalid relationship types."
      },
      "createdAt": "2024-01-01T00:00:00Z",
      "updatedAt": "2024-01-15T10:30:00Z"
    }
  ],
  "pagination": {
    "total": 25,
    "limit": 50,
    "offset": 0,
    "hasMore": false
  },
  "summary": {
    "totalModules": 25,
    "activeModules": 20,
    "deprecatedModules": 3,
    "betaModules": 2,
    "typeBreakdown": {
      "schema": 15,
      "evaluator": 5,
      "verifier": 3,
      "scorer": 2
    },
    "categoryBreakdown": {
      "skill": 8,
      "relationship": 6,
      "achievement": 4,
      "reputation": 3,
      "identity": 4
    }
  },
  "timestamp": "2024-01-20T15:45:00Z"
}
```

## Use Cases

### 1. Module Discovery

Discover available trust modules:

```javascript theme={null}
async function discoverModules(category) {
  const modules = await getTrustModules({ category });
  
  const discovery = {
    schemas: modules.modules.filter(m => m.type === 'schema'),
    evaluators: modules.modules.filter(m => m.type === 'evaluator'),
    verifiers: modules.modules.filter(m => m.type === 'verifier'),
    scorers: modules.modules.filter(m => m.type === 'scorer')
  };
  
  return discovery;
}

// Usage
const skillModules = await discoverModules('skill');
console.log('Available skill schemas:', skillModules.schemas.length);
```

### 2. Schema Validation

Validate attestation data against schemas:

```javascript theme={null}
function validateAttestationData(schema, data) {
  const validation = {
    valid: true,
    errors: [],
    warnings: []
  };
  
  // Check required fields
  schema.schema.fields.forEach(field => {
    if (field.required && !data[field.name]) {
      validation.valid = false;
      validation.errors.push(`Missing required field: ${field.name}`);
    }
  });
  
  // Check field types
  schema.schema.fields.forEach(field => {
    if (data[field.name] && typeof data[field.name] !== field.type) {
      validation.valid = false;
      validation.errors.push(`Invalid type for field ${field.name}: expected ${field.type}`);
    }
  });
  
  return validation;
}
```

### 3. Module Configuration

Configure modules for your application:

```javascript theme={null}
async function configureModules(moduleIds, settings) {
  const configurations = [];
  
  for (const moduleId of moduleIds) {
    const module = await getTrustModules({ id: moduleId });
    
    const configuration = {
      moduleId,
      enabled: settings[moduleId]?.enabled || true,
      settings: {
        ...module.configuration.settings,
        ...settings[moduleId]?.settings
      }
    };
    
    configurations.push(configuration);
  }
  
  return configurations;
}
```

### 4. Module Dependencies

Resolve module dependencies:

```javascript theme={null}
function resolveDependencies(modules) {
  const resolved = [];
  const unresolved = [...modules];
  
  while (unresolved.length > 0) {
    const module = unresolved.shift();
    
    if (module.configuration.dependencies.every(dep => 
      resolved.some(m => m.id === dep)
    )) {
      resolved.push(module);
    } else {
      unresolved.push(module);
    }
  }
  
  return resolved;
}
```

### 5. Module Testing

Test modules before deployment:

```javascript theme={null}
async function testModule(module, testData) {
  const tests = [];
  
  // Test schema validation
  if (module.type === 'schema') {
    const validation = validateAttestationData(module, testData);
    tests.push({
      name: 'Schema Validation',
      passed: validation.valid,
      errors: validation.errors
    });
  }
  
  // Test module functionality
  if (module.capabilities.includes('trust_scoring')) {
    const score = await testTrustScoring(module, testData);
    tests.push({
      name: 'Trust Scoring',
      passed: score > 0,
      score
    });
  }
  
  return tests;
}
```

## Best Practices

### 1. Module Selection

Choose appropriate modules:

```javascript theme={null}
function selectModules(requirements) {
  const modules = await getTrustModules();
  
  const selected = modules.modules.filter(module => {
    return requirements.every(req => 
      module.capabilities.includes(req) || 
      module.category === req
    );
  });
  
  return selected;
}
```

### 2. Version Management

Manage module versions:

```javascript theme={null}
function getLatestVersions(modules) {
  const latest = {};
  
  modules.forEach(module => {
    if (!latest[module.id] || 
        compareVersions(module.version, latest[module.id].version) > 0) {
      latest[module.id] = module;
    }
  });
  
  return Object.values(latest);
}
```

### 3. Caching

Cache module data:

```javascript theme={null}
let moduleCache = new Map();
const CACHE_TTL = 60 * 60 * 1000; // 1 hour

async function getCachedModules(options = {}) {
  const cacheKey = JSON.stringify(options);
  const cached = moduleCache.get(cacheKey);
  
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }
  
  const data = await getTrustModules(options);
  moduleCache.set(cacheKey, {
    data,
    timestamp: Date.now()
  });
  
  return data;
}
```

### 4. Documentation

Generate module documentation:

```javascript theme={null}
function generateModuleDocs(module) {
  return {
    title: module.name,
    description: module.description,
    usage: module.documentation.usage,
    examples: module.examples,
    api: module.documentation.api,
    troubleshooting: module.documentation.troubleshooting
  };
}
```

## Related Endpoints

* [Create Attestation](/api-reference/trust-layer/create-attestation) - Create new attestations
* [Get Attestations](/api-reference/trust-layer/get-attestations) - Retrieve attestations
* [Revoke Attestation](/api-reference/trust-layer/revoke-attestation) - Revoke attestations
* [Evaluate Policy](/api-reference/trust-layer/evaluate-policy) - Evaluate trust policies

## Troubleshooting

### "No modules found"

**Cause**: No modules match the criteria or invalid filters.

**Solution**:

* Remove restrictive filters
* Check if modules exist
* Verify filter values are correct

### "Invalid module type"

**Cause**: Unsupported module type.

**Solution**:

* Use supported types: schema, evaluator, verifier, scorer, all
* Check for typos

### "Invalid category"

**Cause**: Unsupported category value.

**Solution**:

* Use supported categories: identity, skill, relationship, achievement, reputation, custom
* Check for typos

## Rate Limits

Module requests are subject to rate limits:

* **Free tier**: 60 requests per minute
* **Starter tier**: 300 requests per minute
* **Professional tier**: 1,000 requests per minute
* **Enterprise tier**: Custom limits

Implement caching to reduce API calls.