Galxe credentials link participant data to quest eligibility
- last updated
Galxe credentials connect account activity and participant records to the eligibility requirements of a quest. A credential may query a smart contract, match an imported identifier, or request data from an external service. Eligibility follows the configured rule, including the account identifier and any timing restrictions. A successful check establishes that credential's eligibility result; the campaign separately determines access to its rewards.
From account identifiers to eligibility decisions
A credential configuration associates a participant identifier with a data source and a rule that evaluates a specific quest requirement. The ID Type determines what the check identifies, such as a wallet address, social account, or email address. NFT ownership and an approved participant list concern different records, even when both qualify someone for the same quest. The task description should name the condition that its configured source can establish.
REST and GraphQL credentials request information from an external endpoint when a participant clicks Verify. Galxe sends the configured identifier, receives the response, and evaluates it through an expression. For a single-dimension check, that expression returns an eligibility result. The endpoint supplies the data, while the expression decides which returned values satisfy the requirement.
Data freshness, snapshots, and verification deadlines
Credential verification follows the timing of its data source and task settings, so recently completed activity may not appear in every eligibility check immediately.
Current data and stored lists
CSV credentials use manually uploaded records, while Google Sheets credentials synchronize periodically and allow manual updates. An API credential lets a project push changes to its stored eligibility list. REST and GraphQL credentials fetch data during verification, although the external service may maintain its own update schedule. The displayed Update Frequency setting communicates when the project updates its source; it does not configure the frequency of verification requests. An imported identifier must reach the relevant list before a membership-based check can recognize it.
Historical state and end times
A Contract Query snapshot evaluates contract data at a specified block height. With snapshots disabled, the query reads the most recent block state. Later holdings therefore cannot alter an earlier snapshot, while a live holding check can change after a transfer. Reusing transferable holdings across addresses also creates an abuse risk for live eligibility rules. A task can separately set a Participation End Time that closes new verifications. That deadline may differ from the quest end time, so the task's own window matters.
Credential sources and their data scope
Galxe supports imported lists, external queries, and checks of platform activity, with each credential source evaluating its configured data.
| Credential option | Eligibility input | Data delivery | Data scope |
|---|---|---|---|
| Contract Query | Contract function outputs | Read-only contract query | Selected contract, EVM-compatible chain, and block |
| CSV | Imported participant identifiers | Manual file upload | Records included in the uploaded file |
| Google Sheet | Identifiers in a selected column | Periodic synchronization or manual update | Selected worksheet and identifier column |
| API | Stored eligibility-list entries | Project pushes list updates | Configured identifier type and credential list |
| REST | Fields in an endpoint response | Request during verification | JSON response from the configured endpoint |
| GraphQL | Fields selected by a query | Query during verification | Data returned by the configured GraphQL endpoint |
| Space User | Space follows, points, or participation | Galxe platform data | Activity within the specified project Space |
Configure contract inputs and eligibility outputs
Contract Query credentials require compatible contract methods and correctly interpreted outputs, because the selected function determines what the eligibility rule can actually measure.
Contract methods and address parameters
The contract's Application Binary Interface, or ABI, describes its callable functions and their inputs and outputs. Galxe requires a standard function marked view with an address input for this query method. These read-only calls inspect contract state without modifying it. The direct query itself requires no transaction gas payment; any prerequisite blockchain action follows its own transaction rules. The contract address must belong to the selected network, and a missing or incorrect ABI can prevent method selection.
Output values and balance units
Address inputs use the $address placeholder for the participant's address unless the parameter needs a different, explicitly supplied address. Other parameter types require configured values. For balance-related uint256 outputs, the decimals setting normalizes the returned amount for storage and use. A threshold and its evaluated balance must use matching units. Output names and descriptions explain the returned values, while Test Response exposes them for a supplied test address. A successful response establishes what the method returned; the quest's configured criteria determine eligibility.
Why can a completed task still fail verification?
A completed task can fail verification when its credential checks a different identifier, reads an outdated list, or cannot evaluate the configured data source. Imported records must use the identifier type that the task expects. In a manually reviewed Google Forms workflow, submitted entries and approved entries occupy separate worksheets. Only the approved worksheet should supply eligibility. Choosing the raw submissions worksheet admits unreviewed entries, and a pending review can leave a genuine submission outside the accepted list.
An endpoint error also differs from an evaluated ineligible result. GraphQL operations can return HTTP status 200 while the response body contains errors. Integrations must inspect those errors alongside the expected data. Credential queries expose synchronization status, including SYNCING when data is updating. Repeating an on-chain action does not add an omitted identifier to an imported list or repair an inaccessible backend.
X tasks using Page Visit record intent without confirming completed engagement. Authentic Verification checks completed follows, reposts, and quote reposts through X's API; it does not support X Like verification. Spaces at qualifying Rewards Hub levels use finite verification credits; Business+ subscribers have unlimited access. Galxe automatically disables Authentic Verification when finite credits run out, and the project can manually re-enable it once credits return. Authentic action checks alone also do not establish that different social accounts belong to different people.
Credential dimensions and data disclosure
Credential dimensions determine whether a task receives a pass-or-fail result or named values that the quest evaluates through its configured rules.
Single conditions and named counters
A single-dimension REST or GraphQL expression returns the number 1 for eligibility or 0 for ineligibility. A multi-dimensional REST or GraphQL credential instead returns values under configured dimension identifiers. Each dimension has a display name, type, and description, and the quest applies conditions to those values. A counter can describe participation without making every participation level eligible. A Passport Holder requirement can add a separate identity-related condition when the quest includes it. A project's Loyalty Points condition uses the balance within that Space, keeping its threshold distinct from an unrelated credential's result.
Private headers and public expressions
Galxe makes REST and GraphQL credential expressions public. The configuration interface restricts authentication-header access to Space admins. Embedding a secret inside the expression exposes it. The external endpoint also receives the identifier used for its lookup. A wallet-address check and an email-based check therefore transmit different identifying data, which matters when connecting participant records across services.
An imported list suits a project that maintains approved identifiers. REST or GraphQL suits a requirement that an accessible backend calculates during verification.
Galxe credentials questions worth asking
Can a project remove an address from an API credential?
A project with the required permissions can remove an identifier from an API credential through the REMOVE operation. Galxe also supports APPEND for adding entries and REPLACE for replacing the list. These updates require an authenticated access token and admin or owner access to the relevant Space. APPEND and REMOVE are idempotent: repeated additions do not duplicate entries, and repeated removals leave the identifier absent.
Is Starboard still available for new quest credentials?
New Starboards cannot be created because Galxe sunset Starboard on August 3, 2026. Only Spaces that already had a Starboard before that date can use its credential, through the full Quest creation form. Quick Quest Creation does not support Starboard credentials. Those credentials reflect historical, frozen ranking data rather than live tracking, so a newly completed activity does not update that historical ranking.
When does a recurring quest clear its credential verification?
A Recurring Quest resets credential verifications and claims at 00:00 UTC on its configured schedule. Daily cycles reset every day, weekly cycles every Monday, and monthly cycles on the first day of each month. Participants must meet the requirements in the new cycle; an earlier verification does not carry forward as completed status. Daily cycles support Visit a Page and Import Your Own Data tasks. Weekly and monthly cycles also support X tasks. Recurring Quests support Loyalty Points rewards only, so recurrence does not apply universally to every credential and reward combination.
Can a Contract Query credential use a custom RPC connection?
A Contract Query credential can use Customized RPC for an EVM-compatible network outside the built-in chain selection. The endpoint must be accessible and satisfy Galxe's configuration checks. Its eth_call handling must accept the input field that Galxe uses for call data. Custom RPC support does not extend this contract-query method to every blockchain architecture.
How long can a REST credential wait for its backend response?
A REST credential request requires a backend response within five seconds, or Galxe cancels the request. This limit applies to the verification request, not the time allowed to perform the underlying quest task. The response must contain JSON for the configured expression to evaluate. A canceled request does not establish that the participant failed the task's eligibility condition.