Skip to main content
Use this page after Get started and your first Integration loop. It covers DNS, org flows, app linking, and sponsor detail for builders shipping to production. Sign in at https://neus.network/hub to manage profile, apps, and credits.

​
Capabilities

CapabilityUse
Profile trustWallets, socials, domains, badges over time
Domain trustDNS proof; use in onboarding
Linked appsappId, usage attribution
Proof receiptsReusable IDs, not one-off checks
Hosted verify/verify for interactive flows

​
Prerequisites

  • NEUS account + verified wallet
  • Public app or site domain

​
1. Domain verification

DNS TXT at _neus.<domain> proves domain control for trust and linking. Step 1: Add a DNS TXT record at _neus.<yourdomain.com>: 
neus=<your-wallet-address>
Step 2: Create a domain proof: 
const proof = await client.verify({
  verifier: 'ownership-dns-txt',
  data: {
    domain: 'yourdomain.com',
    walletAddress: '0x...',
  },
  walletAddress: '0x...',
  signature: '0x...',
  signedTimestamp: Date.now(),
});
Step 3: Confirm the proof is active: 
GET /api/v1/proofs/check?verifierIds=ownership-dns-txt&address=0x...

​
2. Team and organization verification

When a site or organization needs to verify that someone belongs to a workspace, send them to hosted verify and let NEUS handle the guided Google or Microsoft flow.

​
Setup steps

  1. Launch https://neus.network/verify
  2. Use preset=org-pack when organization membership is the only requirement
  3. Add returnUrl or popup mode for completion handling
  4. Read the returned proof receipt ID after the hosted flow finishes
https://neus.network/verify?preset=org-pack&returnUrl=https://app.example.com/verified
Popup example: 
https://neus.network/verify?preset=org-pack&mode=popup&origin=https://app.example.com

​
Restrict to one company domain only when you need it

If access should only succeed for members of one company or team domain, pass expectedOrgDomain. 
<VerifyGate
  hostedCheckoutUrl="https://neus.network/verify"
  requiredVerifiers={['ownership-org-oauth']}
  verifierData={{
    'ownership-org-oauth': {
      provider: 'google',
      expectedOrgDomain: 'acme.com',
    },
  }}
>
  <ProtectedContent />
</VerifyGate>
Hosted org flows use NEUS OAuth; you usually do not need your own Google or Microsoft OAuth app. Link your integration domain on the NEUS platform so usage, attribution, and billing controls stay attached to the correct product:
StepAction
1Open https://neus.network/hub and start app linking
2Enter app domain, for example app.example.com or https://app.example.com
3Set daily credit cap
4Restrict Origin to real app origins in production
5Send X-Neus-App and Origin headers from your approved domain

​
4. App attribution (API)

To track usage per integration through the same proof layer:
  1. Create or obtain an appId for your integration
  2. Treat appId as a public attribution identifier, not a secret
  3. Include X-Neus-App: <appId> on all API requests
const client = new NeusClient({ appId: 'your-app-id' });

Billing

Credits and payment options.

​
5. Combine trust signals

You can combine these capabilities into one portable verified profile:
  • linked apps
  • domain verification
  • team and organization verification
  • username and namespace claims
  • linked wallets
  • public, private, and unlisted proof visibility
  • proof pages and your platform profile
Typical platform tasks include:
FlowWhereNotes
DomainIdentity settingsAdd DNS TXT at _neus.<domain> first
OrganizationIdentity settingsHosted NEUS verify for Google Workspace or Microsoft 365
UsernameClaim flowsPortable handle and namespace claims
Linked walletsIdentity settingsMultiple wallets as one linked identity
PrivacyPer proofSee Security and trust
Link the app first, then connect only the trust signals your product needs.

​
6. Hosted verify for interactive flows

Interactive checks such as linked accounts, team verification, and human verification should resolve through hosted verify.

​
React (VerifyGate)

import { VerifyGate } from '@neus/sdk/widgets';

<VerifyGate
  apiUrl="https://api.neus.network"
  hostedCheckoutUrl="https://neus.network/verify"
  requiredVerifiers={['ownership-org-oauth']}
  verifierData={{
    'ownership-org-oauth': {
      provider: 'google',
      expectedOrgDomain: 'acme.com',
    },
  }}
  onVerified={(result) => console.log('Verified:', result.proofId)}
>
  <ProtectedContent />
</VerifyGate>
If you do not need to restrict a specific company domain, prefer the simpler preset URL and avoid custom payloads.

​
7. Sponsor grants

If your integration sponsors verification costs: 
const client = new NeusClient({
  appId: 'your-app-id',
  sponsorGrant: '<sponsor-grant-token>',
});
Sponsor grant tokens are short-lived. Re-issue them per session. Do not embed long-lived API keys in client-side code.

​
8. Usage and analytics

Track usage with your appId and your own reporting:
  • proof creation volume by capability
  • gate check counts by app
  • sponsor grant consumption
The /api/v1/proofs/check response includes matchCount for telemetry.

​
What you can manage on the platform

AreaPurpose
DashboardAccount snapshot and recent activity
IdentityDomain and account proofs with privacy controls
AgentsAgent registration and delegation management
AppsDomain-linked app attribution and limits
CreditsBalance management and top-ups
ActivityRequest and verification history

​
Proof pages

Every proof resolves to a public page: 
https://neus.network/proof/[proof-id]
Shows proof receipt ID, verification type and timestamp, visibility state, and share functionality.

​
Portability model

NEUS is most useful when you follow this model:
  • a person has a reusable verified profile
  • that profile can accumulate wallets, linked accounts, domains, team association, and proof-backed badges over time
  • apps can attribute usage and gate access using the same proof layer
  • domains and namespaces can anchor site, community, and organization identity
  • proof receipts are the portable artifact shared across all of it

​
Integration guidelines

  • Keep /verify as the single hosted path for interactive verification
  • Route OAuth and interactive verifier handoffs through NEUS hosted verification
  • Do not create parallel auth routes when NEUS already provides a standard path

Get started

Full builder onboarding.

Proof receipts

Save proofId, not signatures.

Security and trust

Visibility decisions.

Billing

Payers and sponsor detail.