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

# Audit

> Analyze a smart contract for security threats, vulnerabilities, and similar contracts.



## OpenAPI

````yaml openapi.json get /audit
openapi: 3.1.0
info:
  title: EVA API
  description: >-
    Smart contract security analysis API with AI-powered threat detection across
    18+ EVM blockchain networks.
  version: 1.0.0
  contact:
    name: EVA AI Support
    email: evaaiteam@gmail.com
    url: https://dashboard.eva-ai.io
  license:
    name: Proprietary
servers:
  - url: https://dashboard.eva-ai.io/api
    description: Production server
security: []
paths:
  /audit:
    get:
      summary: Audit
      description: >-
        Analyze a smart contract for security threats, vulnerabilities, and
        similar contracts.
      operationId: audit
      parameters:
        - name: chain
          in: query
          required: true
          description: Chain ID (e.g., 1 = Ethereum, 56 = BSC, 8453 = Base)
          schema:
            type: integer
          example: 56
        - name: ca
          in: query
          required: true
          description: Contract address
          schema:
            type: string
          example: '0x2C45560bC707f7aDDb8dF848A9Ba6cd9F30FAEeC'
        - name: x-api-key
          in: header
          required: false
          description: >-
            API key for higher rate limits (optional). Get one at
            dashboard.eva-ai.io
          schema:
            type: string
          example: YOUR_API_KEY
      responses:
        '200':
          description: Successful analysis response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AnalysisResponse'
              example:
                name: Giggle Mascot
                symbol: Max
                decimals: '18'
                totalSupply: '1000000000000000000000000000'
                owner: '0x0000000000000000000000000000000000000000'
                chain: '56'
                tokenAddress: '0x2c45560bc707f7addb8df848a9ba6cd9f30faeec'
                contractName: Token
                isProxy: false
                age: 1739024784000
                initInfo:
                  blockNumber: '46481055'
                  txHash: >-
                    0x65449bf92111b78072e1b232925101fdcb3cdf2a11e41050ccc9b62e853291f6
                  contractCreator: '0x3139576ed8e66cddf0be15f755bf5c5ce5b598a8'
                  timestamp: 1739024562
                threats: []
                auditInfo:
                  ownershipStatus: Renounced
                  flags:
                    - category: Honeypot
                      label: 🟢
                      description: ''
                    - category: Shypooning
                      label: 🟢
                      description: ''
                    - category: Tax Issue
                      label: 🟢
                      description: ''
                    - category: Other Risks
                      label: 🟢
                      description: ''
                similarityMap:
                  - id: '0x628d3ffc9e085c419133274fe984e554b8b4e2ae'
                    symbol: CZBNB
                    chain: '56'
                    score: 0.95
                    exactMatch: true
                    tags: []
                  - id: '0x3a828e1ea6511e367d436c601e14cdb2b446896d'
                    symbol: GATSBY
                    chain: '56'
                    score: 0.81
                    exactMatch: false
                    tags: []
        '400':
          description: Bad request - Missing required parameters
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              example:
                error: Missing chain or contract address
        '404':
          description: Token not found or could not be fetched from the blockchain
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              example:
                error: Token not found or could not be fetched
        '429':
          description: Rate limit exceeded
          headers:
            RateLimit-Limit:
              description: Maximum requests allowed
              schema:
                type: integer
            RateLimit-Remaining:
              description: Remaining requests in current window
              schema:
                type: integer
            RateLimit-Reset:
              description: Time when the rate limit resets
              schema:
                type: string
            Retry-After:
              description: Seconds to wait before retrying
              schema:
                type: integer
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RateLimitError'
              example:
                error: Too many requests
                limit: 60
                retryAfter: 60s
        '500':
          description: Internal server error during analysis
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              example:
                error: Error message describing the issue
      x-codeSamples:
        - lang: curl
          label: cURL
          source: >-
            curl
            'https://dashboard.eva-ai.io/api/audit?chain=56&ca=0x2C45560bC707f7aDDb8dF848A9Ba6cd9F30FAEeC'
            \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: javascript
          label: JavaScript
          source: |-
            const response = await fetch(
              'https://dashboard.eva-ai.io/api/audit?chain=56&ca=0x2C45560bC707f7aDDb8dF848A9Ba6cd9F30FAEeC',
              {
                headers: { 'x-api-key': 'YOUR_API_KEY' }
              }
            );
            const data = await response.json();
        - lang: python
          label: Python
          source: |-
            import requests

            response = requests.get(
                'https://dashboard.eva-ai.io/api/audit',
                params={'chain': 56, 'ca': '0x2C45560bC707f7aDDb8dF848A9Ba6cd9F30FAEeC'},
                headers={'x-api-key': 'YOUR_API_KEY'}
            )
            data = response.json()
        - lang: php
          label: PHP
          source: >-
            <?php

            $ch = curl_init();

            curl_setopt($ch, CURLOPT_URL,
            'https://dashboard.eva-ai.io/api/audit?chain=56&ca=0x2C45560bC707f7aDDb8dF848A9Ba6cd9F30FAEeC');

            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

            curl_setopt($ch, CURLOPT_HTTPHEADER, [
                'x-api-key: YOUR_API_KEY'
            ]);

            $response = curl_exec($ch);

            curl_close($ch);

            $data = json_decode($response, true);
        - lang: go
          label: Go
          source: |-
            package main

            import (
                "net/http"
                "io"
            )

            func main() {
                req, _ := http.NewRequest("GET", "https://dashboard.eva-ai.io/api/audit?chain=56&ca=0x2C45560bC707f7aDDb8dF848A9Ba6cd9F30FAEeC", nil)
                req.Header.Add("x-api-key", "YOUR_API_KEY")
                client := &http.Client{}
                resp, _ := client.Do(req)
                defer resp.Body.Close()
                body, _ := io.ReadAll(resp.Body)
            }
        - lang: java
          label: Java
          source: >-
            HttpClient client = HttpClient.newHttpClient();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://dashboard.eva-ai.io/api/audit?chain=56&ca=0x2C45560bC707f7aDDb8dF848A9Ba6cd9F30FAEeC"))
                .header("x-api-key", "YOUR_API_KEY")
                .build();
            HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());
        - lang: ruby
          label: Ruby
          source: >-
            require 'net/http'

            require 'json'


            uri =
            URI('https://dashboard.eva-ai.io/api/audit?chain=56&ca=0x2C45560bC707f7aDDb8dF848A9Ba6cd9F30FAEeC')

            req = Net::HTTP::Get.new(uri)

            req['x-api-key'] = 'YOUR_API_KEY'

            res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) {
            |http| http.request(req) }

            data = JSON.parse(res.body)
components:
  schemas:
    AnalysisResponse:
      type: object
      properties:
        owner:
          type: string
          description: Current owner address or 'HIDDEN' if renounced
          example: HIDDEN
        tokenAddress:
          type: string
          description: Contract address
          example: '0x00e22ed2c31875abaa34ed0659acb76734b9540d'
        symbol:
          type: string
          description: Token symbol
          example: TEKE
        name:
          type: string
          description: Token name
          example: Akhal Teke
        chain:
          type: string
          description: Chain ID
          example: '56'
        decimals:
          type: string
          description: Token decimals
          example: '18'
        totalSupply:
          type: string
          description: Total token supply in wei
          example: '30000000000000000000000000'
        contractName:
          type: string
          description: Contract name from source code
          example: TEKE
        isProxy:
          type: boolean
          description: Whether contract is a proxy
          example: false
        age:
          type: integer
          format: int64
          description: Token deployment timestamp in milliseconds
          example: 1764063134000
        lastchecked:
          type: integer
          format: int64
          description: Last analysis timestamp in milliseconds
          example: 1767810740203
        initInfo:
          $ref: '#/components/schemas/InitInfo'
        threats:
          type: array
          description: Array of detected security threats.
          items:
            type: string
          example:
            - Honeypot
            - Shypooning
            - Tax Issues
            - Other Risks
            - HolderDistr
        auditInfo:
          $ref: '#/components/schemas/AuditInfo'
        similarityMap:
          type: array
          description: >-
            Array of up to 5 similar tokens detected through AI-based behavioral
            and logical analysis of smart contracts (not a direct or
            line-by-line code comparison).
          maxItems: 5
          items:
            $ref: '#/components/schemas/SimilarToken'
    Error:
      type: object
      required:
        - error
      properties:
        error:
          type: string
          description: Error message describing what went wrong
    RateLimitError:
      type: object
      required:
        - error
      properties:
        error:
          type: string
          description: Error message
          example: Too many requests
        limit:
          type: integer
          description: Request limit that was exceeded
          example: 60
        retryAfter:
          type: string
          description: Time to wait before retrying
          example: 60s
    InitInfo:
      type: object
      description: Deployment information for the token contract
      properties:
        blockNumber:
          type: string
          description: Block number of deployment
          example: '69415413'
        contractCreator:
          type: string
          description: Address that deployed the contract
          example: '0xd0e4b00687445e8cbbd376243c0e41fc85b220b6'
        txHash:
          type: string
          description: Deployment transaction hash
          example: '0x6bcdb3f66193257a1059799852483841dd70feb3e04e564c72812497e971fcb0'
        timestamp:
          type: integer
          format: int64
          description: Deployment timestamp in Unix seconds
          example: 1764062930
    AuditInfo:
      type: object
      description: Security audit results
      properties:
        ownershipStatus:
          type: string
          description: Ownership status of the contract
          enum:
            - Active
            - Renounced
          example: Active
        flags:
          type: array
          description: Array of security check results
          items:
            $ref: '#/components/schemas/AuditFlag'
    SimilarToken:
      type: object
      description: Similar token detected through AI-powered pattern matching
      properties:
        symbol:
          type: string
          description: Token symbol
          example: AZZA
        id:
          type: string
          description: Contract address
          example: '0xc2d49b3358104c764100a3044aefad672ab794da'
        chain:
          type: string
          description: Chain ID where token exists
          example: '8453'
        score:
          type: number
          format: double
          description: Similarity score (0-1, higher = more similar)
          minimum: 0
          maximum: 1
          example: 0.8715265989303589
        exactMatch:
          type: boolean
          description: Whether this is an exact code match
          example: false
        tags:
          type: array
          description: Tags associated with the token (e.g., 'scam', 'verified')
          items:
            type: string
          example: []
    AuditFlag:
      type: object
      description: Individual security check result
      properties:
        category:
          type: string
          description: Security category being checked
          enum:
            - Honeypot
            - Shypooning
            - Tax Issue
            - Other Risks
          example: Honeypot
        label:
          type: string
          description: 'Visual indicator: 🔴 = risk detected, 🟢 = passed'
          enum:
            - 🔴
            - 🟢
          example: 🔴
        description:
          type: string
          description: >-
            Detailed description of the finding. Empty string if the check
            passed.
          example: >-
            The contract uses `subSkip` in `transferFrom`, allowing tax wallets
            to bypass allowance checks, which can be exploited to block
            transfers.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.