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

# Get Nft Collection Assets By Address

> Get the list of NFT assets associated with NFT Collection by collectionAddress.

<Note>**8** credits per request</Note><hr />

<AccordionGroup>
  <Accordion title="Required">
    * collectionAddress: Path parameter. NFT collection contract address.
  </Accordion>

  <Accordion title="Optional">
    * page & limit: Control pagination.
    * rarity: Filter assets by rarity.
  </Accordion>
</AccordionGroup>


## OpenAPI

````yaml /api-reference/openapi.json get /v1/nft/{collectionAddress}/assets
openapi: 3.0.0
info:
  title: CoinStats Public API
  description: >-
    CoinStats Public API — programmatic access to market data, news, NFTs,
    wallets, exchange connections, and user portfolios. Authenticate every
    request with the `X-API-KEY` header (or an OAuth Bearer token in the
    `Authorization` header). Generate keys at https://openapi.coinstats.app.
  version: '1.0'
  contact: {}
servers:
  - url: https://openapiv1.coinstats.app
security: []
tags:
  - name: CoinStats
    description: ''
  - name: Market Data
    description: >-
      The Market Data section of the API provides endpoints to access a wide
      range of market-related information, including cryptocurrency coins,
      ticker data, and fiat currency rates. This category offers comprehensive
      data to help users monitor and analyze the cryptocurrency market, track
      prices, and gain insights into market trends
  - name: News
    description: >-
      The News section of the API allows you to access news articles and updates
      related to cryptocurrencies and the blockchain industry. It provides
      valuable information from various sources to keep you informed about the
      latest developments
  - name: NFTs
    description: >-
      The NFT section of the API provides endpoints to interact with
      Non-Fungible Tokens (NFTs), which are unique digital assets stored on a
      blockchain. These endpoints allow you to retrieve information about NFTs,
      including collections, assets, trending NFTs, and specific assets
      associated with wallet addresses.
  - name: Wallet Data
    description: >-
      The Wallet section of the API provides a comprehensive set of endpoints to
      manage and interact with wallets. It enables users to retrieve wallet
      balances, monitor syncing status, fetch transaction data, and synchronize
      wallet information with the blockchain. By integrating these endpoints
      into your application, you can offer robust wallet functionality to your
      users.
  - name: Exchange Connection
    description: >-
      The Exchange Connection section of the API provides a comprehensive set of
      endpoints to manage and interact with exchanges. It enables users to
      retrieve exchange balances, monitor syncing status, fetch transaction
      data. By integrating these endpoints into your application, you can offer
      robust exchange portfolio tracking functionality to your users.
  - name: User Portfolio
    description: >-
      The Portfolio section of the API provides a comprehensive set of endpoints
      to manage and interact with Share Portfolios. It enables users to retrieve
      current Portfolio Coins and Transactions.
  - name: Usage
    description: The Usage section provides account-level API usage data.
  - name: Status
    description: The Status section provides API availability checks.
paths:
  /v1/nft/{collectionAddress}/assets:
    get:
      tags:
        - NFTs
      summary: >-
        Get the list of NFT assets associated with NFT Collection by
        collectionAddress.
      operationId: get-nft-collection-assets-by-address
      parameters:
        - name: collectionAddress
          required: true
          in: path
          description: The address of the NFT collection
          schema:
            example: '0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d'
            type: string
        - name: page
          required: false
          in: query
          description: Page number to retrieve (1-based indexing)
          schema:
            example: 1
            type: number
        - name: limit
          required: false
          in: query
          description: Number of items to return per page
          schema:
            example: 20
            type: number
        - name: type
          required: false
          in: query
          schema:
            type: string
            enum:
              - listed
              - all
      responses:
        '200':
          description: ''
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/PageDto'
                  - properties:
                      data:
                        type: array
                        items:
                          $ref: '#/components/schemas/NftAssetItemResponseDto'
        '400':
          description: Bad Request
          content:
            application/json:
              example:
                statusCode: 400
                message: Bad Request
                requestId: 11111111-2222-3333-4444-555555555555
                path: <requested-endpoint>
        '401':
          description: Unauthorized
          content:
            application/json:
              example:
                statusCode: 401
                message: Unauthorized
                requestId: 11111111-2222-3333-4444-555555555555
                path: <requested-endpoint>
        '403':
          description: Forbidden
          content:
            application/json:
              example:
                statusCode: 403
                message: Forbidden
                requestId: 11111111-2222-3333-4444-555555555555
                path: <requested-endpoint>
        '404':
          description: Not Found
          content:
            application/json:
              example:
                statusCode: 404
                message: Not Found
                requestId: 11111111-2222-3333-4444-555555555555
                path: <requested-endpoint>
        '409':
          description: Conflict (for some endpoints)
          content:
            application/json:
              example:
                statusCode: 409
                message: Transactions not synced
                requestId: 11111111-2222-3333-4444-555555555555
                path: <requested-endpoint>
        '429':
          description: Too Many Requests
          content:
            application/json:
              example:
                statusCode: 429
                message: Rate limit exceeded
                requestId: 11111111-2222-3333-4444-555555555555
                path: <requested-endpoint>
        '503':
          description: Service Unavailable
          content:
            application/json:
              example:
                statusCode: 503
                message: Service Unavailable. Please Contact Support
      security:
        - X-API-KEY: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |-
            curl --request GET \
              --url 'https://openapiv1.coinstats.app/v1/nft/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/assets' \
              --header 'X-API-KEY: <api-key>'
        - lang: python
          label: Python
          source: >-
            import requests


            url =
            "https://openapiv1.coinstats.app/v1/nft/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/assets"


            headers = {"X-API-KEY": "<api-key>"}


            response = requests.request("GET", url, headers=headers)


            print(response.json())
        - lang: javascript
          label: JavaScript
          source: >-
            const options = {method: 'GET', headers: {'X-API-KEY':
            '<api-key>'}};


            fetch('https://openapiv1.coinstats.app/v1/nft/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/assets',
            options)
              .then((response) => response.json())
              .then((response) => console.log(response))
              .catch((err) => console.error(err));
        - lang: php
          label: PHP
          source: |-
            <?php

            $curl = curl_init();

            curl_setopt_array($curl, [
              CURLOPT_URL => "https://openapiv1.coinstats.app/v1/nft/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/assets",
              CURLOPT_RETURNTRANSFER => true,
              CURLOPT_CUSTOMREQUEST => "GET",
              CURLOPT_HTTPHEADER => [
                "X-API-KEY: <api-key>"
              ],
            ]);

            $response = curl_exec($curl);
            $err = curl_error($curl);

            curl_close($curl);

            if ($err) {
              echo "cURL Error #:" . $err;
            } else {
              echo $response;
            }
        - lang: go
          label: Go
          source: "package main\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n)\n\nfunc main() {\n\n\turl := \"https://openapiv1.coinstats.app/v1/nft/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/assets\"\n\n\treq, _ := http.NewRequest(\"GET\", url, nil)\n\n\treq.Header.Add(\"X-API-KEY\", \"<api-key>\")\n\n\tres, _ := http.DefaultClient.Do(req)\n\n\tdefer res.Body.Close()\n\tbody, _ := io.ReadAll(res.Body)\n\n\tfmt.Println(string(body))\n}"
        - lang: java
          label: Java
          source: >-
            HttpResponse<String> response =
            Unirest.get("https://openapiv1.coinstats.app/v1/nft/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d/assets")
              .header("X-API-KEY", "<api-key>")
              .asString();
components:
  schemas:
    PageDto:
      type: object
      properties:
        meta:
          $ref: '#/components/schemas/PageMetaDto'
      required:
        - meta
    NftAssetItemResponseDto:
      type: object
      properties:
        address:
          type: string
          description: The contract address of the NFT
          example: '0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d'
        blockchain:
          type: string
          description: The blockchain network where the NFT exists
          example: ethereum
        tokenId:
          type: string
          description: The unique token ID of the NFT within the collection
          example: '0'
        attributes:
          description: Array of NFT attributes/traits with detailed metadata
          example:
            - key: Background
              kind: string
              value: Orange
              tokenCount: 1274
              onSaleCount: 41
              floorAskPrice: 10.5
              topBidValue: 10
              createdAt: '2024-01-27T07:15:58.523Z'
            - key: Clothes
              kind: string
              value: Striped Tee
              tokenCount: 412
              onSaleCount: 10
              floorAskPrice: 10.72
              topBidValue: null
              createdAt: '2024-01-27T07:15:58.719Z'
          type: array
          items:
            $ref: '#/components/schemas/NftAssetAttributeType'
        collectionId:
          type: string
          description: Unique identifier for the NFT collection
          example: e1d92f9a882dd4db91feabe806a326af
        name:
          type: string
          description: Name of the NFT (can be null for some NFTs)
          example: null
          nullable: true
        previewUrl:
          type: string
          description: URL for the preview/thumbnail image of the NFT
          example: >-
            https://img.reservoir.tools/images/v2/mainnet/7%2FrdF%2Fe%2F0iXY8HduhRCoIehkmFeXPeOQQFbbmIPfjCZeLloToqp073iyCX%2FAT3E6uYDqjoHHp1CsuC3u6gJ%2BxixS6XKRAFdBaJMUefz4QR69ZDW9ItgF7Bv047qTmFku0Hxt5Ib2RmfppbDYaFxKWQ%3D%3D
        rarityRank:
          type: number
          description: >-
            Rarity rank of the NFT within its collection (lower numbers indicate
            higher rarity)
          example: 2673
        rarityScore:
          type: number
          description: Numerical rarity score calculated based on trait distribution
          example: 75.409
        source:
          type: string
          description: Data source provider for the NFT information
          example: reservoir
        standard:
          type: string
          description: NFT token standard (ERC721, ERC1155, etc.)
          example: ERC721
        url:
          type: string
          description: Full-resolution image URL of the NFT
          example: >-
            https://img.reservoir.tools/images/v2/mainnet/i9YO%2F4yHXUdJsWcTqhqvf%2BytcG2XMhnD4zz%2BhMYH9%2FZK%2FhVtu%2B3gYAAVBBdL1dsMoZPY79XY4AQ%2FN91VDNlxaLilzKrcVKu%2FcHUBfdHr%2BSM%3D
        lastSaleDate:
          format: date-time
          type: string
          description: Date of the last sale transaction for this NFT
          example: '2024-01-15T10:30:00.000Z'
        lastSalePrice:
          type: number
          description: Price of the last sale transaction for this NFT
          example: 15.75
        listSource:
          description: Source platform where the NFT is currently listed
          example: opensea
          allOf:
            - $ref: '#/components/schemas/NftAssetListSourceType'
        listPrice:
          type: number
          description: Current listing price of the NFT if it is for sale
          example: 20.5
      required:
        - address
        - blockchain
        - tokenId
        - attributes
        - collectionId
        - name
        - previewUrl
        - rarityRank
        - rarityScore
        - source
        - standard
        - url
    PageMetaDto:
      type: object
      properties:
        page:
          type: number
          description: Current page number (1-based)
          example: 2
          minimum: 1
        limit:
          type: number
          description: Number of items per page
          example: 20
          minimum: 1
          maximum: 1000
        itemCount:
          type: number
          description: Total number of items across all pages
          example: 150
          minimum: 0
        pageCount:
          type: number
          description: Total number of pages available
          example: 8
          minimum: 0
        hasPreviousPage:
          type: boolean
          description: Whether there is a previous page available
          example: true
        hasNextPage:
          type: boolean
          description: Whether there is a next page available
          example: true
      required:
        - page
        - limit
        - itemCount
        - pageCount
        - hasPreviousPage
        - hasNextPage
    NftAssetAttributeType:
      type: object
      properties:
        key:
          type: string
          description: The attribute/trait name
          example: Background
        kind:
          type: string
          description: The data type of the attribute value
          example: string
        value:
          type: string
          description: The attribute value
          example: Orange
        tokenCount:
          type: number
          description: Total number of tokens in the collection with this attribute value
          example: 1274
        onSaleCount:
          type: number
          description: Number of tokens with this attribute currently listed for sale
          example: 41
        floorAskPrice:
          type: number
          description: Lowest asking price for tokens with this attribute (nullable)
          example: 10.5
          nullable: true
        topBidValue:
          type: number
          description: Highest bid value for tokens with this attribute (nullable)
          example: 10
          nullable: true
        createdAt:
          type: string
          description: ISO timestamp when this attribute was created/indexed
          example: '2024-01-27T07:15:58.523Z'
      required:
        - key
        - kind
        - value
        - tokenCount
        - onSaleCount
        - floorAskPrice
        - topBidValue
        - createdAt
    NftAssetListSourceType:
      type: object
      properties: {}
  securitySchemes:
    X-API-KEY:
      type: apiKey
      in: header
      name: X-API-KEY
      description: >-
        API key required to access the endpoints. Generate one from your
        dashboard at https://openapi.coinstats.app and pass it in the
        `X-API-KEY` request header. Never expose your key in client-side code.

````