.nav-dropdown-content {
	width: var(--radix-dropdown-menu-trigger-width);
}

.nav-dropdown-item[data-dropdown-item="CDP API v2"] > .nav-dropdown-item-text-container > .nav-dropdown-item-title::after {
  content: "Beta" !important;
  background-color: #004cec1a;
  color: #0052ff;
  font-size: 0.75rem;
  font-weight: 600;
  padding: 2px 8px;
  border-radius: 12px;
  margin-left: 8px;
}


@font-face {
  font-family: 'Coinbase Text Medium';
  src: url('https://mintlify-assets.b-cdn.net/fonts/coinbase/Coinbase_Text-Medium-web-1.32.woff2') format('woff2');
  font-weight: 500;
  font-style: normal;
}

.dark li[id="topbar-cta-button"] > a > span {
  background-color: #578BF9 !important;
}

.dark li[id="topbar-cta-button"] > a > div > svg {
  color: #101521 !important;
}

.dark li[id="topbar-cta-button"] > a > div > span {
  color: #101521 !important;
}

div[data-callout-type='info'] {
  background-color: #f5f8fe !important;
  color: #0052fe !important;
  border-color: #ccdcfe !important;
}

div[data-callout-type='info'] > div > svg {
  color: white !important;
}

div[data-callout-type='info'] > div > svg > path {
  fill: #0052fe !important;
}

.dark div[data-callout-type='info'] {
  background-color: #001133 !important;
  color: #578bf9 !important;
  border-color: #2c406c !important;
}

.dark div[data-callout-type='info'] > div > svg > path {
  fill: #578bf9 !important;
}

div[data-callout-type='note'] {
  background-color: rgba(250, 250, 250, 0.5) !important;
  color: #578bf9 !important;
  border-color: rgba(113, 113, 122, 0.2) !important;
}

div[data-callout-type='note'] > div > svg {
  color: white !important;
}

div[data-callout-type='note'] > div > ul > li {
  color: #18181b !important;
}

.dark div[data-callout-type='note'] > div > ul > li {
  color: #e4e4e7 !important;
}

div[data-callout-type='note'] > div > svg > path {
  fill: #0052fe !important;
}

.dark div[data-callout-type='note'] {
  background-color: rgba(113, 113, 122, 0.1) !important;
  color: #578bf9 !important;
  border-color: rgba(113, 113, 122, 0.3) !important;
}

.dark div[data-callout-type='note'] > div > svg > path {
  fill: #578bf9 !important;
}

.dark div[data-callout-type='note'] > div > p {
  color: #e4e4e7 !important;
}
div[data-callout-type='note'] > div > p {
  color: #18181b !important;
}

#\/ {
  display: none;
}

h1,
h2,
span {
  letter-spacing: 0.02em !important;
}

/* Nav section header styles */
.nav-section-header {
  font-size: 0.7rem !important;
  font-weight: 600 !important;
  text-transform: uppercase !important;
  letter-spacing: 0.05em !important;
  color: #6b7280 !important;
  padding: 12px 8px 4px 8px !important;
  margin-bottom: 4px !important;
}

.nav-section-header.with-divider {
  border-top: 1px solid #e5e7eb !important;
  margin-top: 8px !important;
}

.dark .nav-section-header {
  color: #9ca3af !important;
}

.dark .nav-section-header.with-divider {
  border-top-color: rgba(255, 255, 255, 0.1) !important;
}

.version-option:hover {
  background-color: #f1f5f9 !important;
}

.dark .version-option:hover {
  background-color: #4b5563 !important;
}

/* Version-specific visibility rules to prevent flash on page load */
/* Initially hide v1 Wallet API content by default */
li[data-group-tag="v1"][data-title="Wallet API"] {
  display: none !important;
}

/* Show v1 content only when the URL contains v1 */
body.url-contains-v1 li[data-group-tag="v1"][data-title="Wallet API"] {
  display: block !important;
}

/* Ensure v2 content is visible by default */
li[data-group-tag="v2"][data-title="Wallet API"] {
  display: block !important;
}

/* Hide v2 content when v1 is active */
body.url-contains-v1 li[data-group-tag="v2"][data-title="Wallet API"] {
  display: none !important;
}

.nav-tag-pill-text[data-nav-tag="v1"] {
  cursor: pointer !important;
  user-select: none !important;
  display: flex !important;
  align-items: center !important;
  padding: 2px 8px !important;
}

.nav-tag-pill-text[data-nav-tag="v2"] {
  cursor: pointer !important;
  user-select: none !important;
  display: flex !important;
  align-items: center !important;
  padding: 2px 8px !important;
}

/* Add dropdown arrow using ::after pseudo-element */
.nav-tag-pill-text[data-nav-tag="v1"]::after,
.nav-tag-pill-text[data-nav-tag="v2"]::after {
  color: #004cec !important;
  content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 24 24' fill='none' stroke='%23004cec' stroke-width='3' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='m6 9 6 6 6-6'/%3E%3C/svg%3E");
  margin-left: 4px;
  padding-top: 4px;
  opacity: 0.6;
}

#footer > div {
  padding-top: 5rem !important;
  padding-bottom: 4rem !important;
}

.tab-container > ul {
margin-bottom: 1rem !important;
}

.code-block {
  margin-top: 0px !important;
}

button[data-component-part="tab-button"] {
  font-size: 1rem !important;
}

@media (min-width: 1024px) {
  div[id="content-container"] {
    padding-left: 4rem !important;
    padding-right: 1rem !important;
  }
}

#sidebar-title {
  font-family: 'Coinbase Text Medium', sans-serif !important;
  color: #111827 !important;
  font-size: 0.8rem !important;
  font-weight: 500 !important;
}

.dark #sidebar-title {
  font-family: 'Coinbase Text Medium', sans-serif !important;
  color: #e5e7eb !important;
  font-size: 0.8rem !important;
  font-weight: 500 !important;
}


// Get the target element - specifically the inner div with the disclaimer text
const targetElement = document.querySelector("#chat-assistant-sheet > div > div.chat-assistant-sheet-content > div > div");

if (targetElement) {
    // Clear the existing content
    targetElement.textContent = "";
    
    // Create the disclaimer text
    const disclaimerText = document.createTextNode("This is an AI generated summary and may contain mistakes. It is not intended to give advice, including legal, financial or tax advice. It does not have access to your account information. By using this AI-assistant, you agree to the ");
    
    // Create the link element
    const tosLink = document.createElement("a");
    tosLink.href = "https://www.coinbase.com/legal/developer-platform/terms-of-service";
    tosLink.textContent = "CDP ToS";
    tosLink.target = "_blank";
    tosLink.rel = "noopener noreferrer";
    tosLink.style.borderBottom = "1px solid rgb(var(--primary))";
    
    // Add the period after the link
    const period = document.createTextNode(".");
    
    // Append all elements to the disclaimer div
    targetElement.appendChild(disclaimerText);
    targetElement.appendChild(tosLink);
    targetElement.appendChild(period);
}


const isProduction = window.location.hostname === 'docs.cdp.coinbase.com';

const DEVELOPMENT_ENVIRONMENT_ID = '5ZyvBnXc4D7y';
const PRODUCTION_ENVIRONMENT_ID = 'zxxktKL2Pd1v';

const ENVIRONMENT_ID = isProduction ? PRODUCTION_ENVIRONMENT_ID : DEVELOPMENT_ENVIRONMENT_ID;

// code below comes from https://docs.sprig.com/docs/web-javascript#install-with-html-recommended
(function (l, e, a, p) {
  if (window.Sprig) return;
  window.Sprig = function () {
    S._queue.push(arguments);
  };
  var S = window.Sprig;
  S.appId = a;
  S._queue = [];
  window.UserLeap = S;
  a = l.createElement('script');
  a.async = 1;
  a.src = e + '?id=' + S.appId;
  p = l.getElementsByTagName('script')[0];
  p.parentNode.insertBefore(a, p);
})(document, 'https://cdn.sprig.com/shim.js', ENVIRONMENT_ID);

const { execSync } = require('child_process');
const path = require('path');

const specId = process.argv[2];

const openApiSpecs = [
  {
    id: 'cdp-api-v2',
    name: 'CDP API V2',
    url: 'https://drla6sbl8l00t.cloudfront.net/openapi.yaml',
    path: path.join(__dirname, '../api-reference/v2/cdp-api-v2.yaml'),
  },
];

openApiSpecs.forEach((spec) => {
  if (spec.id !== specId) {
    return;
  }

  console.log(`Fetching latest ${spec.name} OpenAPI spec...`);
  // Add a random query parameter to prevent retrieval of a cached copy from CloudFront
  const urlWithNoCacheParam = `${spec.url}?nocache=${Date.now()}`;
  execSync(`curl ${urlWithNoCacheParam} -o ${spec.path}`, { stdio: 'inherit' });
});

/**
 * Script to generate error documentation from OpenAPI specifications.
 *
 * The generated documentation is organized by HTTP status code and error type,
 * with up to MAX_EXAMPLES unique examples per error type.
 *
 * @usage node generate-openapi-error-page.js <spec-id>
 * @example node generate-openapi-error-page.js cdp-api-v2
 */

const path = require('path');
const fs = require('fs');
const yaml = require('js-yaml');

const baseUrl = 'https://docs.cdp.coinbase.com/';
const specId = process.argv[2];

const openApiSpecs = [
  {
    id: 'cdp-api-v2',
    name: 'CDP API V2',
    specPath: path.join(__dirname, '../api-reference/v2/cdp-api-v2.yaml'),
    outputPath: path.join(__dirname, '../api-reference/v2/errors.mdx'),
  },
];

// Add validation for spec-id
if (!specId) {
  console.error('Error: No spec-id provided');
  console.error('Usage: node generate-openapi-error-page.js <spec-id>');
  process.exit(1);
}

const matchingSpec = openApiSpecs.find((spec) => spec.id === specId);
if (!matchingSpec) {
  console.error(`Error: Invalid spec-id "${specId}"`);
  console.error('Available spec-ids:', openApiSpecs.map((s) => s.id).join(', '));
  process.exit(1);
}

/**
 * Resolves a reference in the OpenAPI spec
 * @param {string} ref - The reference path (e.g. '#/components/responses/IdempotencyError')
 * @param {Object} spec - The full OpenAPI specification
 * @returns {Object} The resolved reference object
 */
function resolveRef(ref, spec) {
  const refParts = ref.replace('#/', '').split('/');
  return refParts.reduce((obj, key) => obj[key], spec);
}

/**
 * Gets the complete example by combining schema defaults with provided example
 * @param {Object} schema - The error schema definition
 * @param {Object} spec - The full OpenAPI specification for resolving refs
 * @param {Object} example - The provided example values
 * @returns {Object} Complete example with all schema fields
 */
function getCompleteExample(schema, spec, example = {}) {
  // If no example was provided, return null to skip this error
  if (Object.keys(example).length === 0) {
    return null;
  }

  // If schema is a reference, resolve it
  if (schema.$ref) {
    schema = resolveRef(schema.$ref, spec);
  }

  const complete = { ...example };

  // Add any missing required fields from schema
  if (schema.properties) {
    Object.entries(schema.properties).forEach(([field, prop]) => {
      if (!(field in complete)) {
        // If property is a reference, resolve it
        const resolvedProp = prop.$ref ? resolveRef(prop.$ref, spec) : prop;

        // Use example from property definition if available
        if (resolvedProp.example) {
          complete[field] = resolvedProp.example;
        } else if (resolvedProp.default) {
          complete[field] = resolvedProp.default;
        } else {
          // Use a descriptive placeholder for missing fields
          complete[field] = `<${field}>`;
        }
      }
    });

    // Add errorLink after all other properties are set
    const errorType = complete.errorType || 'error-type';
    complete.errorLink = `${baseUrl}api-reference/v2/errors#${errorType}`;
  }

  return complete;
}

/**
 * Extracts error responses from an OpenAPI path object
 * @param {Object} pathObj - The OpenAPI path object containing response definitions
 * @param {Object} spec - The full OpenAPI specification for resolving refs
 * @returns {Array} Array of error objects with status, description and schema
 */
function extractErrorResponses(pathObj, spec) {
  const errors = [];

  // Look through each method (GET, POST, etc)
  Object.values(pathObj).forEach((method) => {
    if (!method.responses) return;

    // Look for error responses (4xx, 5xx)
    Object.entries(method.responses).forEach(([status, response]) => {
      if (!status.startsWith('4') && !status.startsWith('5')) return;

      // Resolve reference if present
      const resolvedResponse = response.$ref ? resolveRef(response.$ref, spec) : response;

      // Only process if there's a JSON schema
      if (resolvedResponse?.content?.['application/json']?.schema) {
        const { schema } = resolvedResponse.content['application/json'];
        const resolvedSchema = schema.$ref ? resolveRef(schema.$ref, spec) : schema;

        // Handle both single example and multiple examples
        const examples =
          resolvedResponse.content['application/json'].examples ||
          (resolvedResponse.content['application/json'].example
            ? { default: { value: resolvedResponse.content['application/json'].example } }
            : {});

        // Process each example
        Object.entries(examples).forEach(([exampleName, exampleObj]) => {
          const completeExample = getCompleteExample(resolvedSchema, spec, exampleObj.value);

          // Skip if no complete example could be generated
          if (!completeExample) return;

          errors.push({
            status,
            description: resolvedResponse.description,
            schema: resolvedSchema,
            example: completeExample,
            exampleName, // Include example name for multiple examples
          });
        });
      }
    });
  });

  return errors;
}

/**
 * Gets error instructions for a given error type
 * @param {string} errorType - The error type to get instructions for
 * @param {Object} spec - The full OpenAPI specification
 * @returns {string|null} The error instructions markdown if found, null otherwise
 */
function getErrorInstructions(errorType, spec) {
  // Look for instructions in the ErrorType schema
  const errorTypeSchema = spec.components.schemas.ErrorType;
  if (errorTypeSchema?.['x-error-instructions']?.[errorType]) {
    return errorTypeSchema['x-error-instructions'][errorType];
  }
  return null;
}

/**
 * Replaces absolute URLs that start with baseUrl with relative links in generated content
 * Keeps errorLink as an absolute URL
 * @param {string} content - The content to process
 * @returns {string} Content with absolute URLs replaced by relative links
 */
function replaceAbsoluteUrls(content) {
  if (!baseUrl) return content;

  // Skip URLs in JSON examples (errorLink should remain as absolute URL)
  const parts = [];
  let inCodeBlock = false;
  let currentPart = '';

  content.split('\n').forEach((line) => {
    if (line.startsWith('```')) {
      inCodeBlock = !inCodeBlock;
      currentPart += `${line}\n`;

      if (!inCodeBlock) {
        // We've reached the end of a code block, add it without changes
        parts.push(currentPart);
        currentPart = '';
      }
    } else if (inCodeBlock) {
      // Inside a code block, don't replace URLs
      currentPart += `${line}\n`;
    } else {
      // Regular markdown text, replace absolute URLs with relative ones
      // Use a regex to match URLs that start with baseUrl
      const regex = new RegExp(`${baseUrl}([^\\s")]+)`, 'g');
      const replacedLine = line.replace(regex, (match, urlPath) => {
        return `/${urlPath}`;
      });
      currentPart += `${replacedLine}\n`;
    }
  });

  // Add any remaining content
  if (currentPart) {
    parts.push(currentPart);
  }

  return parts.join('');
}

/**
 * Generates markdown documentation for API errors
 * @param {Object} spec - The parsed OpenAPI specification
 * @returns {string} Markdown formatted error documentation
 */
function generateErrorDocs(spec) {
  let markdown = `---
title: Errors
---

# API Errors

The CDP API uses conventional HTTP response codes to indicate the success or failure of an API request. 
In general:

- Codes in the \`2xx\` range indicate success
- Codes in the \`4xx\` range indicate an error that failed given the information provided (e.g., a 
  required parameter was omitted)
- Codes in the \`5xx\` range indicate an error on CDP's backend servers. 

  <Info>
  \`5xx\` errors are not a guarantee of failure; there's always the chance that the operation may have 
  succeeded in our back-end. Therefore, your application should treat the operation's status as 
  **unknown**.
  </Info>

Each error response includes:
- \`errorType\`: A machine-readable error code
- \`errorMessage\`: A human-readable message providing more detail
- \`correlationId\`: A unique identifier for the request that can help with debugging
- \`errorLink\`: A link to detailed documentation about the specific error type

`;

  // Group errors by status code and error type
  const errorsByStatus = new Map();
  const MAX_EXAMPLES = 3;

  Object.entries(spec.paths).forEach(([, pathObj]) => {
    const errors = extractErrorResponses(pathObj, spec);
    errors.forEach((error) => {
      if (!errorsByStatus.has(error.status)) {
        errorsByStatus.set(error.status, new Map());
      }
      const errorTypeMap = errorsByStatus.get(error.status);
      const { example } = error;
      const errorType = example?.errorType || 'unknown';

      // Store all examples for this error type
      if (!errorTypeMap.has(errorType)) {
        errorTypeMap.set(errorType, {
          description: error.description,
          examples: [],
          instructions: getErrorInstructions(errorType, spec),
        });
      }

      // Add this example if it's unique and we haven't hit the limit
      const errorInfo = errorTypeMap.get(errorType);
      const isDuplicate = errorInfo.examples.some(
        (e) => JSON.stringify(e) === JSON.stringify(example),
      );
      if (!isDuplicate && errorInfo.examples.length < MAX_EXAMPLES) {
        errorInfo.examples.push(example);
      }
    });
  });

  // Sort by status code
  const sortedStatuses = Array.from(errorsByStatus.keys()).sort();

  // Generate documentation for each status code and its error types
  sortedStatuses.forEach((status) => {
    markdown += `## HTTP ${status}\n\n`;

    const errorTypeMap = errorsByStatus.get(status);
    const errorTypes = Array.from(errorTypeMap.entries());

    errorTypes.forEach(([errorType, error]) => {
      markdown += `### ${errorType}\n\n`;

      // Add error instructions if they exist
      if (error.instructions) {
        markdown += `${error.instructions}\n\n`;
      }

      // Add up to MAX_EXAMPLES examples for this error type
      error.examples.forEach((example, index) => {
        if (error.examples.length > 1) {
          markdown += `**Example ${index + 1}:**\n\n`;
        } else {
          markdown += `**Example error response:**\n\n`;
        }
        markdown += `\`\`\`json lines wrap\n${JSON.stringify(example, null, 2)}\n\`\`\`\n\n`;
      });
    });
  });

  return markdown;
}

openApiSpecs.forEach((spec) => {
  if (spec.id !== specId) {
    return;
  }

  console.log(`Reading ${spec.name} OpenAPI spec...`);

  try {
    // Read and parse YAML file
    const fileContents = fs.readFileSync(spec.specPath, 'utf8');
    const openApiSpec = yaml.load(fileContents);

    // Generate error documentation
    const errorDocs = generateErrorDocs(openApiSpec);

    // Process the content to replace absolute URLs with relative links
    // This doesn't affect errorLink in JSON examples which will remain absolute
    const processedDocs = replaceAbsoluteUrls(errorDocs);

    // Write to output file
    fs.writeFileSync(spec.outputPath, processedDocs);
    console.log(`Generated error documentation at ${spec.outputPath}`);
  } catch (error) {
    console.error('Error processing OpenAPI spec:', error);
    process.exit(1);
  }
});

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

// Configuration
const OPENAPI_PATH = path.join(__dirname, '..', 'api-reference', 'v2', 'cdp-api-v2.yaml');
const API_REFERENCE_DIR = path.join(__dirname, '..', 'api-reference', 'v2', 'rest-api');

// Mapping of tag names to their overview file paths
const TAG_TO_FILE_MAPPING = {
  'EVM Accounts': 'evm-accounts/evm-accounts.mdx',
  'EVM Smart Accounts': 'evm-smart-accounts/evm-smart-accounts.mdx',
  'EVM Swaps': 'evm-swaps/evm-swaps.mdx',
  'EVM Token Balances': 'evm-token-balances/evm-token-balances.mdx',
  'Faucets': 'faucets/faucets.mdx',
  'Payments (Alpha)': 'payments/payments.mdx',
  'Policy Engine': 'policy-engine/policy-engine.mdx',
  'Solana Accounts': 'solana-accounts/solana-accounts.mdx',
  'x402 Facilitator': 'x402-facilitator/x402-facilitator.mdx'
};

// Simple YAML parser for tags section
function extractTagsFromYAML(yamlContent) {
  const tags = [];
  
  // Find the tags section - match until we hit a line that's not indented (next top-level key)
  const tagsMatch = yamlContent.match(/^tags:\s*\n((?:(?:  |\s{2,}).*\n)*)/m);

  if (!tagsMatch) {
    return tags;
  }
  
  const tagsSection = tagsMatch[1];
  
  // Split by tag entries (starting with "  - name:")
  const tagEntries = tagsSection.split(/(?=^  - name:)/m).filter(entry => entry.trim());
  
  for (const entry of tagEntries) {
    const nameMatch = entry.match(/name:\s*(.+)/);
    const descriptionMatch = entry.match(/description:\s*(?:\|-?\s*\n)?((?:(?:      |\s{6,}).*\n?)*)/);
    
    if (nameMatch && descriptionMatch) {
      const name = nameMatch[1].trim();
      let description = descriptionMatch[1];
      
      // Clean up the description - preserve relative indentation
      const lines = description.split('\n');
      
      // Find the minimum indentation (excluding empty lines)
      const minIndent = lines
        .filter(line => line.trim())
        .reduce((min, line) => {
          const indent = line.match(/^(\s*)/)[1].length;
          return Math.min(min, indent);
        }, Infinity);
      
      // Remove the base indentation while preserving relative indentation
      description = lines
        .map(line => line.slice(minIndent))
        .join('\n')
        .trim();
      
      tags.push({ name, description });
    }
  }
  
  return tags;
}

// Function to read and parse the OpenAPI spec
function readOpenAPISpec() {
  try {
    const fileContents = fs.readFileSync(OPENAPI_PATH, 'utf8');
    return fileContents;
  } catch (error) {
    console.error('Error reading OpenAPI spec:', error);
    process.exit(1);
  }
}

// Function to extract tag descriptions from OpenAPI spec
function extractTagDescriptions(yamlContent) {
  const tagDescriptions = {};
  const tags = extractTagsFromYAML(yamlContent);
  
  tags.forEach(tag => {
    if (tag.name && tag.description) {
      tagDescriptions[tag.name] = tag.description;
    }
  });
  
  return tagDescriptions;
}

// Function to update MDX file with new description
function updateMDXFile(filePath, tagName, description) {
  const fullPath = path.join(API_REFERENCE_DIR, filePath);
  
  // Check if file exists
  if (!fs.existsSync(fullPath)) {
    console.warn(`Warning: File not found: ${fullPath}`);
    return false;
  }
  
  try {
    let content = fs.readFileSync(fullPath, 'utf8');
    
    // Find the frontmatter section
    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n/);
    if (!frontmatterMatch) {
      console.warn(`Warning: No frontmatter found in ${filePath}`);
      return false;
    }
    
    const frontmatter = frontmatterMatch[1];    
    
    // Create new content with updated description
    const newContent = `---
${frontmatter}
---

${description}
`;
    
    // Write the updated content
    fs.writeFileSync(fullPath, newContent, 'utf8');
    console.log(`✓ Updated ${filePath}`);
    return true;
    
  } catch (error) {
    console.error(`Error updating ${filePath}:`, error);
    return false;
  }
}

// Main function
function main() {
  console.log('Starting OpenAPI overview pages update...\n');
  
  // Read OpenAPI spec
  const yamlContent = readOpenAPISpec();
  console.log('✓ OpenAPI spec loaded successfully\n');
  
  // Extract tag descriptions
  const tagDescriptions = extractTagDescriptions(yamlContent);
  console.log(`Found ${Object.keys(tagDescriptions).length} tags with descriptions\n`);
  
  // Update each overview file
  let successCount = 0;
  let totalCount = 0;
  
  for (const [tagName, filePath] of Object.entries(TAG_TO_FILE_MAPPING)) {
    totalCount++;
    
    if (tagDescriptions[tagName]) {
      console.log(`Processing: ${tagName}`);
      if (updateMDXFile(filePath, tagName, tagDescriptions[tagName])) {
        successCount++;
      }
    } else {
      console.warn(`Warning: No description found for tag "${tagName}"`);
    }
    console.log('');
  }
  
  console.log(`\nUpdate complete! Successfully updated ${successCount}/${totalCount} files.`);
}

// Run the script
main();


List all assets available for a given entity.

List Assets

The number of decimals supported for the asset

Base URL to our recommended block explorer (crypto only)

The mutable series of letters used to identify the asset

Indicates whether this asset can be traded

The network id: base, bitcoin, ethereum, solana etc

The name of the network

The network type

Indicates whether this network is the default network for the asset

Indicates whether this network requires a destination tag

The maximum number of decimals supported for this network

Indicates whether this network supports prime custody

Indicates whether this network supports trading

Indicates whether this network supports vault

Coinbase

Explore our API & SDK references, demos, and guides for building onchain apps.

Home

Coinbase Developer Docs

Quickstart

Develop with Coinbase

Use AI Tooling

Using docs with AI-powered IDEs

Supported Networks

Supported networks using CDP

Comparing Our Wallets

Smart Wallet

Introduction

Welcome to Onchain Data

Get programmatic access to Coinbase products.

Overview

Welcome

Welcome to Coinbase App APIs

Welcome to Coinbase Business APIs

Explore our SDKs for building onchain apps, AI agents, and more.

REST API

FIX API

Websocket Feed

List Assets

Path Parameters

Response