Field reference - Colosseum

These are the fields for each endpoint in the API overview. You don’t need them to use Copilot through your agent. Fields are written in a short schema notation, not as sample responses:

[optional] means the field can be left out. null is a separate value from a missing field.
[default x] is the value used when the field is left out.
int means a whole number. Bounds on arrays count items; bounds on strings count characters.
Dates are ISO 8601 strings. Request objects marked [strict] reject unknown fields.
v2CategoryKey is one of the 41 category keys from GET /categories.

Your own data

arenaProfile

The signed-in profile and Arena-visible teammate profiles use these fields:

displayName: string | null
username: string | null
bio: string | null
city: string | null
country: string | null
languages: Array<string>
currentPosition: string | null
lookingToBuild: string | null
lookingForCollab: boolean
isUniversityStudent: boolean | null
roles: Array<string>
rolesLookingFor: Array<string>
skills: Array<string>
interestedUseCases: Array<string>
githubHandle: string | null
linkedinHandle: string | null
twitterHandle: string | null
telegramHandle: string | null

A teammate without a visible Arena profile has only displayName and username. No teammate email is returned.

meResponse

Returned by GET /me for the signed-in person. submission can contain draft and private fields.

profile: arenaProfile & { cofounderMatching: { hasProfile: boolean; publicPageUrl: string [url] | null } }
currentHackathon: { name: string; slug: string; registered: boolean }
projects: Array<{
  name: string; slug: string | null; publicPageUrl: string [url] | null
  program: { type: "hackathon" | "eternal"; name: string; slug: string; current: boolean }
  status: "draft" | "submitted"; role: "owner" | "member"
  tracks: Array<string>; description: string
  submission: {
    category: string | null; otherProductCategory: string | null; country: string | null
    website: string | null; repoLink: string | null; presentationLink: string | null
    technicalDemoLink: string | null; pitchVideoLink: string | null; demoVideoLink: string | null
    demoVideoPublic: boolean; twitterHandle: string | null; telegramHandle: string | null
    liveProductLink: string | null; liveProductAccessInstructions: string | null
    additionalInfo: string | null; whatBuilding: string | null; whyNow: string | null
    technologies: string | null; repoContext: string | null; marketValidation: string | null
    traction: string | null; competition: string | null; monetization: string | null
    teamCommitment: string | null; teamLocationDetails: string | null; chainUsage: string | null
    chains: Array<string>; externalContributors: string | null
    isUniversityProject: boolean; universityName: string | null; isSolanaMobile: boolean
    acceleratorOptIn: boolean | null; legalEntity: boolean | null; legalEntityDetails: string | null
    investmentReceived: boolean | null; investmentDetails: string | null
    currentlyFundraising: boolean | null; fundraisingDetails: string | null
    liveToken: boolean | null; liveTokenDetails: string | null
    surveyAnswers: unknown | null
    eternalDetails: { targetAudience: string; teamSuitability: string; startedAndPriorities: string; raised: string; productDescription: string } | null
  }
  teammates: Array<arenaProfile | { displayName: string | null; username: string | null }>
  prize: { type: string; name: string | null; amount: number | null; placement: number | null; honorableMention: boolean } | null
  acceleratorCompany: { name: string; cohort: string } | null
  updates: Array<{ kind: "hackathon" | "eternal" | "buildLog"; number: number [int] | null; publishedAt: string [datetime]; links: Array<string> }>
}>
truncated: { projects: boolean; updates: boolean }

prize is non-null only after the results are published. The response returns at most 200 projects and 2,000 updates across them; truncated marks either cap. It does not include judging scores, reviews or application status.

Projects

searchProjectsRequest

query: string [trim, max 500] [optional] [default ""]
hackathons: Array<string [min 1]> [max 10] [optional]
trackKeys: Array<string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/]> [max 10] [optional]
labelKeys: Array<string [pattern /^label:[a-z0-9-]+\/[a-z0-9-]+$/]> [max 10] [optional]
limit: number [int, min 1, max 25] [default 10]
offset: number [int, min 0] [default 0]
filters: { categoryKeys: Array<v2CategoryKey | "other-emerging" | "insufficient-information"> [min 1, max 10] [optional]; includeSecondaryCategories: boolean [optional, default false]; builtWith: builtWithFilters [optional]; winnersOnly: boolean [optional]; acceleratorOnly: boolean [optional]; acceleratorBatchKeys: Array<string [pattern /^accelerator\/[a-z0-9-]+$/]> [max 10] [optional]; prizePlacements: Array<number [int]> [optional]; prizeTypes: Array<string> [max 10] [optional]; isUniversityProject: boolean [optional]; isSolanaMobile: boolean [optional]; techStack: Array<string> [max 10] [optional]; primitives: Array<string> [max 10] [optional]; problemTags: Array<string> [max 10] [optional]; solutionTags: Array<string> [max 10] [optional]; targetUsers: Array<string> [max 10] [optional] } [strict] [optional]
diversify: boolean [optional] [default false]
includeFacets: boolean [optional] [default false]
facets: Array<"categories" | "hackathons" | "tracks" | "labels" | "clusters" | "prizes" | "problemTags" | "solutionTags" | "primitives" | "techStack"> [optional]
facetTopK: number [int, min 1, max 43 with includeFacets and "categories" in facets; otherwise max 20] [optional] [default 8]
includeDiagnostics: boolean [optional] [default false]

trackKeys and labelKeys cannot be combined. tracks lists the prize tracks a project entered, not the one it won; the winning track is prize.trackName. labels contains submission choices for events without track prizes. ambiguous returns neither until classification is resolved. filters.categoryKeys matches any listed key. filters.includeSecondaryCategories: true also matches a project’s second category; category counts can then overlap. filters.winnersOnly excludes honorable mentions. diversify spreads results across hackathons and tracks.

searchProjectsResponse

results: Array<projectSearchResult>
filtersApplied: { hackathons: Array<string> [optional]; trackKeys: Array<string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/]> [optional]; labelKeys: Array<string [pattern /^label:[a-z0-9-]+\/[a-z0-9-]+$/]> [optional]; filters: { categoryKeys: Array<v2CategoryKey | "other-emerging" | "insufficient-information"> [min 1, max 10] [optional]; includeSecondaryCategories: boolean [optional, default false]; builtWith: builtWithFilters [optional]; winnersOnly: boolean [optional]; acceleratorOnly: boolean [optional]; acceleratorBatchKeys: Array<string [pattern /^accelerator\/[a-z0-9-]+$/]> [max 10] [optional]; prizePlacements: Array<number [int]> [optional]; prizeTypes: Array<string> [max 10] [optional]; isUniversityProject: boolean [optional]; isSolanaMobile: boolean [optional]; techStack: Array<string> [max 10] [optional]; primitives: Array<string> [max 10] [optional]; problemTags: Array<string> [max 10] [optional]; solutionTags: Array<string> [max 10] [optional]; targetUsers: Array<string> [max 10] [optional] } [strict] [optional] }
totalFound: number [int]
hasMore: boolean
categoryCountsOverlap: boolean [optional]
facets: { categories: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; clusters: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; hackathons: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; tracks: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; labels: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; prizes: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; problemTags: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; solutionTags: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; primitives: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional]; techStack: Array<{ key: string; label: string; count: number [int]; sampleProjectSlugs: Array<string> }> [optional] } [optional]
diagnostics: searchDiagnostics [optional]

With an empty query, totalFound is the exact number of matching projects. With a text query, it only supports paging. categoryCountsOverlap is true when category counts include second categories.

projectSearchResult

builtWith: compactBuiltWith | null [optional]
categories: { version: string; primaryKey: v2CategoryKey | "other-emerging" | "insufficient-information"; secondaryKey: v2CategoryKey | null; confidence: "high" | "medium" | "low" } | null [optional]
slug: string
name: string
oneLiner: string | null
similarity: number
hackathon: { name: string; slug: string; startDate: string }
tracks: Array<{ name: string; key: string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/] }>
labels: Array<string>
trackClassification: "prize_tracks" | "submission_labels" | "ambiguous"
award: "winner" | "honorable_mention" | null
crowdedness: number [int] | null
cluster: { key: string [pattern /^v\d+-c\d+$/]; label: string } | null
links: { github: string | null; demo: string | null; presentation: string | null; technicalDemo: string | null; twitter: string | null; colosseum: string | null; repoPublic: boolean [optional] }
evidence: Array<string> [max 2]
corpusRevision: string [optional]
freshness: projectFreshness [optional]
prize: { type: string; name: string | null; placement: number [int] | null; amount: number | null; trackName: string | null } | null
metrics: { updatesCount: number [int] }
team: { count: number [int] }
tags: { problemTags: Array<string> [max 10]; solutionTags: Array<string> [max 10]; primitives: Array<string> [max 10]; techStack: Array<string> [max 10]; targetUsers: Array<string> [max 10] } | null
accelerator: { companySlug: string | null; companyName: string | null; batchKey: string [pattern /^accelerator\/[a-z0-9-]+$/]; batchName: string } | null

evidence holds up to two matching snippets. builtWith lists up to 10 tool names per kind; fetch project details for the full record. award: "honorable_mention" identifies honorable mentions. They carry prize.type: "HONORABLE_MENTION" with no amount, and they’re recognitions, not wins. prize.trackName is the track a project won. Frontier had no tracks: its 25 TRACK_PRIZE awards named Winner are its top-25 awards, not track prizes.

searchDiagnostics

Returned when includeDiagnostics is true.

modeUsed: "vector" | "text" | "hybrid" | "filters"
fallbackUsed: boolean
fallbackReason: string [optional]
vectorCandidates: number [int]
textCandidates: number [int]
tagCandidates: number [int]
diversityDropped: number [int]
missingVectorProjects: number [int] [optional]
missingVectorMatches: number [int] [optional]
totalFoundIsEstimate: boolean
queryExpanded: string
effectiveFilters: Record<string, unknown>

modeUsed says how results were ranked. "vector" scores by similarity (higher is closer), "hybrid" combines similarity, text and tags, "text" uses a fixed score, and "filters" (an empty query) scores 0 and lists newest first. Compare scores only within the same mode.

getProjectBySlugParams

slug: string

projectDetails

builtWith: repositoryTags | null [optional]
categories: { version: string; primaryKey: v2CategoryKey | "other-emerging" | "insufficient-information"; secondaryKey: v2CategoryKey | null; confidence: "high" | "medium" | "low" } | null [optional]
evidenceSummaries: projectEvidence [optional]
corpusRevision: string [optional]
freshness: projectFreshness [optional]
slug: string
name: string
description: string | null
oneLiner: string | null
hackathon: { name: string; slug: string; startDate: string }
tracks: Array<{ name: string; key: string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/] }>
labels: Array<string>
trackClassification: "prize_tracks" | "submission_labels" | "ambiguous"
award: "winner" | "honorable_mention" | null
cluster: { key: string [pattern /^v\d+-c\d+$/]; label: string } | null
links: { github: string | null; demo: string | null; presentation: string | null; technicalDemo: string | null; twitter: string | null; colosseum: string | null; repoPublic: boolean [optional] }
team: { count: number [int]; members: Array<{ displayName: string | null; username: string | null; githubHandle: string | null; twitterHandle: string | null }> }
isWinner: boolean
accelerator: { companySlug: string | null; companyName: string | null; batchKey: string [pattern /^accelerator\/[a-z0-9-]+$/]; batchName: string } | null
createdAt: string
tags: { problemTags: Array<string> [max 10]; solutionTags: Array<string> [max 10]; primitives: Array<string> [max 10]; techStack: Array<string> [max 10]; targetUsers: Array<string> [max 10] } | null
metrics: { updatesCount: number [int] } | null
prize: { type: string; name: string | null; placement: number [int] | null; amount: number | null; trackName: string | null } | null

isWinner is false for honorable mentions. categories.confidence says how clearly the project fits its main category, not how good it is. categories: null means the project hasn’t been categorized yet.

projectEvidence

Summaries of what the team submitted: its code, pitch and demo. A missing summary means Copilot has none, not that the team submitted nothing.

repoSummary: projectEvidenceSummary | null
pitchSummary: projectEvidenceSummary | null
demoSummary: projectEvidenceSummary | null

projectEvidenceSummary

text: string [max 12000]
truncated: boolean
sourceUrl: string [url] | null
sourceRevision: string
sourceCapturedAt: string [datetime] | null
generatedAt: string [datetime] | null
indexedAt: string [datetime]
capturedAt: string [datetime] | null
sourceInferred: boolean
evidenceId: string | null
extractorVersion: string

text keeps Markdown up to 12,000 characters; truncated is true only when that limit cuts it off. sourceUrl links the public repository, presentation or demo, or is null when no valid link is known. The linked page may have changed since capture. sourceCapturedAt is when the source was captured; capturedAt is the same value under an older name. generatedAt is when the summary was written, and indexedAt is when Copilot last took it in. None of these dates show whether the project is still active. sourceInferred is true when the source was matched by type rather than declared by the team.

projectFreshness

projectsSyncedAt: string [datetime] | null
embeddingsVersion: string | null
archiveIngestedAt: string [datetime] | null

Tools found in a project’s code

builtWith lists the tools found in a project’s public code when it was captured. It doesn’t show that the project still runs, or how the tools are used. builtWith: null means no record is available. An empty list for one kind means none was found, not that none was used. Project details return up to 100 tools per kind. Each has a display name, a confidence from 0 to 1, and an evidence quote of up to 120 characters. A version appears only when the source states one. Projects whose code isn’t public return names only, without confidence or evidence.

repositoryTags

schemaVersion: 1
languages: Array<repositoryTag> [max 100]
frameworks: Array<repositoryTag> [max 100]
chains: Array<repositoryChainTag> [max 100]
protocols: Array<repositoryTag> [max 100]
services: Array<repositoryTag> [max 100]
tooling: Array<repositoryTag> [max 100]
standards: Array<repositoryTag> [max 100]

repositoryTag

name: string [trim, min 1, max 100]
version: string [trim, min 1, max 100] [optional]
confidence: number [min 0, max 1] [optional]
evidence: string [max 120] [optional]

repositoryChainTag

Includes the repositoryTag fields and:

network: "mainnet" | "devnet" | "testnet" | "localnet" | "unknown" [optional]

compactBuiltWith

The shorter form used in search results.

languages: Array<string [trim, min 1, max 100]> [max 10]
frameworks: Array<string [trim, min 1, max 100]> [max 10]
chains: Array<string [trim, min 1, max 100]> [max 10]
protocols: Array<string [trim, min 1, max 100]> [max 10]
services: Array<string [trim, min 1, max 100]> [max 10]
tooling: Array<string [trim, min 1, max 100]> [max 10]
standards: Array<string [trim, min 1, max 100]> [max 10]

builtWithFilters

languages: Array<string [trim, min 1, max 100]> [max 20] [optional]
frameworks: Array<string [trim, min 1, max 100]> [max 20] [optional]
chains: Array<string [trim, min 1, max 100]> [max 20] [optional]
protocols: Array<string [trim, min 1, max 100]> [max 20] [optional]
services: Array<string [trim, min 1, max 100]> [max 20] [optional]
tooling: Array<string [trim, min 1, max 100]> [max 20] [optional]
standards: Array<string [trim, min 1, max 100]> [max 20] [optional]

Names match exactly, ignoring case and surrounding spaces, with no aliases. Kinds combine with AND; names within one kind combine with OR. For example, this finds Cypherpunk projects tagged with Solana and either Kamino Lend or Jupiter:

{
  "query": "",
  "hackathons": ["cypherpunk"],
  "filters": {
    "builtWith": {
      "chains": ["Solana"],
      "protocols": ["Kamino Lend", "Jupiter"]
    }
  },
  "limit": 10
}

These filters are separate from the older techStack tags.

filtersResponse

tracks: Array<{ key: string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/]; name: string; hackathonSlug: string; projectCount: number }>
labels: Array<{ key: string [pattern /^label:[a-z0-9-]+\/[a-z0-9-]+$/]; name: string; hackathonSlug: string; projectCount: number }>
hackathons: Array<{ slug: string; name: string; startDate: string; projectCount: number; winnerCount: number }>
acceleratorBatches: Array<{ key: string [pattern /^accelerator\/[a-z0-9-]+$/]; name: string; companyCount: number [int] }>
prizeTypes: Array<string>
prizePlacements: Array<number [int]>
problemTags: Array<{ tag: string; count: number [int] }>
solutionTags: Array<{ tag: string; count: number [int] }>
primitives: Array<{ tag: string; count: number [int] }>
techStack: Array<{ tag: string; count: number [int] }>
targetUsers: Array<{ tag: string; count: number [int] }>
archiveSources: Array<{ key: string; label: string; documentCount: number [int] [optional] }>
clusters: Array<{ key: string [pattern /^v\d+-c\d+$/]; label: string; projectCount: number [int] }>

Analysis

analyzeRequest

cohort: { hackathons: Array<string [min 1]> [optional]; trackKeys: Array<string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/]> [optional]; winnersOnly: boolean [optional]; acceleratorOnly: boolean [optional]; acceleratorBatchKeys: Array<string [pattern /^accelerator\/[a-z0-9-]+$/]> [optional]; prizePlacements: Array<number [int]> [optional]; clusterKeys: Array<string [pattern /^v\d+-c\d+$/]> [optional]; categoryKeys: Array<v2CategoryKey | "other-emerging" | "insufficient-information"> [min 1, max 10] [optional]; includeSecondaryCategories: boolean [optional, default false] } [strict]
dimensions: Array<"categories" | "clusters" | "tracks" | "problemTags" | "solutionTags" | "primitives" | "techStack" | "targetUsers">
topK: number [int, min 1, max 43 with "categories" in dimensions; otherwise max 20] [default 10]
samplePerBucket: number [int, min 0, max 5] [default 2]

Category buckets count main categories unless cohort.includeSecondaryCategories is true. For every category bucket at once, use dimensions: ["categories"] with topK: 43.

analyzeResponse

categoryCountsOverlap: boolean [optional]
totals: { projects: number [int]; winners: number [int] }
buckets: Record<string, Array<{ key: string; label: string; count: number [int]; share: number; sampleProjectSlugs: Array<string> }>>

totals.winners excludes honorable mentions.

cohortDefinition

Used by POST /compare.

hackathons: Array<string [min 1]> [optional]
trackKeys: Array<string [pattern /^[a-z0-9-]+\/[a-z0-9-]+$/]> [optional]
winnersOnly: boolean [optional]
acceleratorOnly: boolean [optional]
acceleratorBatchKeys: Array<string [pattern /^accelerator\/[a-z0-9-]+$/]> [optional]
prizePlacements: Array<number [int]> [optional]
clusterKeys: Array<string [pattern /^v\d+-c\d+$/]> [optional]

compareRequest

cohortA: cohortDefinition
cohortB: cohortDefinition
dimensions: Array<"clusters" | "tracks" | "problemTags" | "solutionTags" | "primitives" | "techStack" | "targetUsers">
topK: number [int, min 1, max 20] [default 10]

compareResponse

totalsA: { projects: number [int]; winners: number [int] }
totalsB: { projects: number [int]; winners: number [int] }
results: Record<string, Array<{ key: string; label: string; countA: number [int]; shareA: number; countB: number [int]; shareB: number; lift: number; delta: number; examplesA: Array<string>; examplesB: Array<string> }>>

totalsA.winners and totalsB.winners exclude honorable mentions.

Technologies

Technology requests

technology: { category: "languages" | "frameworks" | "chains" | "protocols" | "services" | "tooling" | "standards"; name: string [trim, min 1, max 100] }
cohort: {
  hackathonSlugs: Array<string [pattern /^[a-z0-9-]+$/]> [min 1, max 20] [optional]
  winnersOnly: boolean [default false]
  includeHonorableMentions: boolean [default false, requires winnersOnly]
  categoryKeys: Array<v2CategoryKey | "other-emerging" | "insufficient-information"> [min 1, max 10] [optional]
  includeSecondaryCategories: boolean [optional]
} [strict] [optional]
topK: number [int, min 1, max 50] [default 10, co-usage and top only]
technologyCategory: same values as technology.category [optional, top only]

Counts and trends take technology and cohort. Co-usage adds topK. Top takes cohort, technologyCategory and topK.

Technology counts and trends

technology: { category: string; name: string }
totals: { projects: number [int]; projectsWithRepositoryTags: number [int]; count: number [int]; share: number [0 to 1] } [counts only]
hackathons: Array<{ hackathon: { slug: string; name: string; startDate: string | null }; projects: number [int]; projectsWithRepositoryTags: number [int]; count: number [int]; share: number [0 to 1] }>

projects is the number of projects in the cohort, projectsWithRepositoryTags how many have recorded tools, and count how many are tagged with the technology. share is count / projects. Hackathons are in date order. Names come back in lowercase.

Technologies used together

technology: { category: string; name: string }
totals: { projects: number [int]; projectsWithRepositoryTags: number [int]; count: number [int]; share: number [0 to 1] }
results: Array<{ technology: { category: string; name: string }; count: number [int]; share: number [0 to 1]; cohortCount: number [int]; lift: number }>

In each result, count is the number of projects tagged with both technologies, and share is that count divided by the number tagged with the requested one. cohortCount is how many projects in the cohort are tagged with the other technology. lift is share / (cohortCount / projects): above 1 means the two appear together more often than the other technology appears overall. Results are ordered by count.

Top technologies

totals: { projects: number [int]; projectsWithRepositoryTags: number [int] }
results: Array<{ technology: { category: string; name: string }; count: number [int]; share: number [0 to 1] }>

Results are ordered by count. Several hackathons in one cohort are combined; request each separately to rank them separately.

Research library

searchArchivesRequest

query: string [trim, max 500, min 1]
sources: Array<string> [max 20] [optional]
limit: number [int, min 1, max 10] [default 5]
offset: number [int, min 0, max 50] [default 0]
maxChunksPerDoc: number [int, min 1, max 4] [default 2]
maxDocsPerSource: number [int, min 0, max 10] [optional] [default 3]
intent: "ideation" | "docs" [optional] [default "docs"]
minSimilarity: number [min 0, max 1] [optional] [default 0.2]

searchArchivesResponse

results: Array<archiveSearchResult>
filtersApplied: { sources: Array<string> [optional] }
searchTier: "vector" | "chunk_text" | "doc_text"
totalFound: number [int]
totalMatched: number [int]
hasMore: boolean

archiveSearchResult

documentId: string [uuid]
title: string
author: string | null
source: string
url: string | null
publishedAt: string | null
similarity: number
snippet: string [max 240 characters]
chunkIndex: number

getArchiveDocumentParams

documentId: string [uuid]

archiveDocumentPageQuery

offset: number [int, min 0] [coerced] [optional]
maxChars: number [int, min 200, max 20000] [coerced] [optional]

archiveDocumentPage

documentId: string [uuid]
title: string
author: string | null
source: string
url: string | null
publishedAt: string | null
content: string
restricted: boolean
isExcerpt: boolean
excerptNote: string [optional, for excerpts]
offset: number [int]
maxChars: number [int]
totalChars: number [int]
nextOffset: number [int] | null
hasMore: boolean

For excerpt-only sources, isExcerpt and restricted are true, and totalChars, nextOffset and hasMore describe only the excerpt.

Tools and FAQs

eventDates

V2 resources, FAQ lists and FAQ details include eventDates. Resources carry the dates of the requested hackathon. FAQ responses carry the dates of the most recently started hackathon, and null when the response has no hackathon FAQ (for example program=accelerator). winnerAnnouncementDate is null until Colosseum records it. Check the event’s page before giving timing advice.

hackathonSlug: string
startDate: string [datetime]
submissionDeadline: string [datetime]
winnerAnnouncementDate: string [datetime] | null

resourcesResponse

Returned by GET /resources.

eventDates: eventDates | null
hackathon: { name: string; slug: string; pageUrl: string [optional] }
tracks: Array<{ id: string; name: string; pageUrl: string [optional]; sponsorCards: Array<{ name: string; slug: string; trackId: string; fallback: boolean; comingSoon: boolean }> [optional]; sponsorCardsNote: string [optional] }>
source: { url: string; fetchedAt: string [datetime]; stale: boolean }
sponsors: Array<{ name: string; slug: string; trackId: string [optional]; tags: Array<string>; hasSkill: boolean; content: string; links: Array<resourceLink> }>
topics: Array<{ id: string; trackId: string [optional]; title: string; summary: string [optional]; groups: Array<{ id: string; title: string; links: Array<resourceLink> }> }>
topicGroups: Array<{ id: string; trackId: string [optional]; title: string; topicIds: Array<string> }>
rpcProviders: Array<{ name: string; trackId: string [optional]; description: string; offer: string [optional]; links: Array<resourceLink> }>
query: { track: string [optional]; q: string [optional]; topic: string [optional]; kind: string; matched: number [int] }
resourceLink: { label: string; url: string; description: string [optional, topic links only] }

query.matched counts the sponsors, topic links and RPC providers returned. topicGroups lists only returned topics. A hackathon with a single track returns tracks: [].

faqsResponse

Returned by GET /faqs. GET /faqs/:program/:id returns { eventDates, source, faq }.

eventDates: eventDates | null
source: { kind: string; revision: string [sha256 digest] }
programs: Array<{ program: string; count: number [int] }>
faqs: Array<faq>
query: { program: string [optional]; q: string [optional]; matched: number [int] }
faq: { program: "hackathon" | "eternal" | "accelerator" | "stamp"; id: string; question: string; answer: string; answerFormat: "markdown"; sourceUrl: string; contentRevision: string [sha256 digest]; links: Array<{ label: string; url: string }> }

Account and feedback

statusResponse

authenticated: boolean
expiresAt: string | null
scope: string | null
sessionSharingEnabled: boolean [optional; true only if the user opted in to sharing]

scope is a space-separated list of granted scopes. expiresAt and scope can be null when unknown.

sourceSuggestionRequest

url: string [url]
name: string [max 200, optional]
reason: string [max 500, optional]

feedbackRequest

category: "error" | "quality" | "suggestion" | "other"
message: string [trim, min 1, max 5000]
context: Record<string, unknown> [optional]
severity: "low" | "medium" | "high" | "critical" [default "medium"]

​Your own data

​arenaProfile

​meResponse

​Projects

​searchProjectsRequest

​searchProjectsResponse

​projectSearchResult

​searchDiagnostics

​getProjectBySlugParams

​projectDetails

​projectEvidence

​projectEvidenceSummary

​projectFreshness

​Tools found in a project’s code

​repositoryTags

​repositoryTag

​repositoryChainTag

​compactBuiltWith

​builtWithFilters

​filtersResponse

​Analysis

​analyzeRequest

​analyzeResponse

​cohortDefinition

​compareRequest

​compareResponse

​Technologies

​Technology requests

​Technology counts and trends

​Technologies used together

​Top technologies

​Research library

​searchArchivesRequest

​searchArchivesResponse

​archiveSearchResult

​getArchiveDocumentParams

​archiveDocumentPageQuery

​archiveDocumentPage

​Tools and FAQs

​eventDates

​resourcesResponse

​faqsResponse

​Account and feedback

​statusResponse

​sourceSuggestionRequest

​feedbackRequest