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

# Get a project's Blockscout card

> Trustblock API route to get a project's Blockscout card



## OpenAPI

````yaml GET /v1/project/blockscout-card
openapi: 3.0.0
info:
  title: Trustblock Public API
  version: 1.1.0
  description: >
    The public routes of the Trustblock API, as they behave today.


    This document is a description, not a promise. It covers only the `/v1`
    routes that are available

    to callers outside Trustblock; internal routes used by the website and by
    administrators are

    deliberately absent. Where current behaviour is inconsistent and under
    review, the route says so

    rather than picking the answer we would prefer.


    Every route requires a bearer token. There is no unauthenticated route.
  contact:
    name: Trustblock documentation
    url: https://docs.trustblock.run
servers:
  - url: https://api.trustblock.run
    description: Production. This is the only server.
security: []
tags:
  - name: Project security
    description: Read the published audit state of a project.
  - name: Cards
    description: Compact summaries for third-party block explorers.
  - name: Publishing
    description: Routes for audit providers to publish and correct their own audits.
paths:
  /v1/project/blockscout-card:
    get:
      tags:
        - Cards
      summary: Get a project's Blockscout card
      description: >
        The same summary as the Etherscan card, in the shape Blockscout
        consumes: counts and auditor

        names rather than display strings.


        Identified the same way as `/v1/project/security`. **This route consumes
        no API credit.**


        The counts carry the same five states as the Etherscan card, without
        wording: `activeRektsNumber`

        (incident), `activeCriticalIssuesNumber` (open critical),
        `acknowledgedCriticalIssuesNumber`

        (acknowledged critical), all three zero (none open), and `isFound:
        false` (no audit). It carries

        the same `contractLine`, under the same rule, the same five-minute cache
        on `chain` +

        `address` lookups, and the same `Cache-Control` and key-check cache.


        It shares the Etherscan card's answers: `200` with `isFound: false` when
        the project is unknown,

        has no audit, or `chain` is a chain Trustblock does not record; and an
        error status - `503` if a

        dependency was briefly unreachable, `500` otherwise - when the lookup
        itself fails.
      operationId: getProjectBlockscoutCard
      parameters:
        - in: query
          name: domain
          required: false
          schema:
            type: string
        - in: query
          name: slug
          required: false
          schema:
            type: string
        - in: query
          name: chain
          required: false
          description: >-
            One of the chain names below, or a decimal EVM chain id (`1`, `56`,
            `8453`...). A chain Trustblock does not record - an unknown id or
            name - answers `200` with `isFound: false` (no card), never an
            error.
          schema:
            type: string
            example: ethereum
        - in: query
          name: address
          required: false
          schema:
            type: string
      responses:
        '200':
          description: A card, found or not found.
          headers:
            Cache-Control:
              description: >-
                `public, max-age=300`. A card may be reused for five minutes.
                Error answers carry no Cache-Control.
              schema:
                type: string
                example: public, max-age=300
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetBlockscoutCardResponse'
        '400':
          description: The query is unusable - for example `chain` without `address`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '401':
          description: No `Authorization` header was sent.
        '403':
          description: The bearer token is not a recognised key.
        '500':
          description: The lookup failed. This is not a statement about the project.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '503':
          description: >-
            A dependency was briefly unreachable and the request is worth
            retrying. Carries `Retry-After`, in seconds.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
      security:
        - BearerAuth: []
components:
  schemas:
    GetBlockscoutCardResponse:
      type: object
      required:
        - isFound
        - extra
      properties:
        isFound:
          type: boolean
          description: >-
            False when there is no card: an unknown project, a project with no
            audit, or a chain Trustblock does not record. The response is then
            `isFound` and `extra` only.
        contractLine:
          type: string
          description: >-
            The same line, under the same rule, as the Etherscan card's
            `contractLine`. Absent otherwise.
        auditsNumber:
          type: number
          description: The project's audits on Trustblock.
        auditors:
          type: array
          description: The names of the firms that audited the project.
          items:
            type: string
        activeCriticalIssuesNumber:
          type: number
          description: >-
            Open Critical findings - neither fixed nor acknowledged - across the
            audits still in force.
        activeHighIssuesNumber:
          type: number
          description: >-
            Open High findings, reported beside the Critical count rather than
            merged into it. `activeCriticalIssuesNumber` counts Critical only.
        acknowledgedCriticalIssuesNumber:
          type: number
          description: >-
            Critical findings the client acknowledged without fixing, in the
            audits still in force. Not included in `activeCriticalIssuesNumber`.
        activeRektsNumber:
          type: number
          description: >-
            Unresolved rekts recorded against the project. Reported here as well
            as on the Etherscan card: a project can have no unresolved critical
            issue and still have been rekt.
        latestRektAt:
          type: number
          nullable: true
          description: >-
            Milliseconds since the Unix epoch, for the most recent unresolved
            rekt. Null when there is none.
        isAIScan:
          type: boolean
        extra:
          $ref: '#/components/schemas/Extra'
    Error:
      type: object
      required:
        - message
        - extra
      properties:
        message:
          type: string
          description: A short, non-localised description of the failure.
          example: Not found.
        code:
          type: string
          description: A stable machine-readable code, where one applies.
        diagnoses:
          type: array
          description: Field-level detail, present on validation failures.
          items:
            type: object
        extra:
          $ref: '#/components/schemas/Extra'
    Extra:
      type: object
      description: Present on every response, including errors.
      required:
        - requestId
      properties:
        requestId:
          type: string
          description: Quote this when reporting a problem.
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: >
        `Authorization: Bearer <key>`.


        For the project and card routes, the key is an API key belonging to an
        onboarded integrator or

        to an active audit provider. The publishing routes accept only an audit
        provider's credential.

        Sending no `Authorization` header produces `401`; sending one that is
        not recognised produces

        `403`.

````

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