NEAR Auth

Let your users sign NEAR transactions with the accounts they already have — Google, Apple, email, or passkeys — while keys stay secured by a Multi-Party Computation network.

\~5 min React TypeScript

Add social login to your dApp

Wrap your app in a provider and use hooks to authenticate users and request signatures — no wallet integration required.

Start the quickstart → Providers, hooks, and the signer API. Login, logout, and session handling.

```tsx App.tsx theme={"theme":{"light":"github-light","dark":"github-dark"}} import { FastAuthProvider, useIsLoggedIn, useFastAuth } from "@fast-auth-near/react-sdk"; import { JavascriptProvider } from "@fast-auth-near/javascript-provider"; const provider = new JavascriptProvider({ network: "mainnet", clientId: "", }); function LoginButton() { const { client } = useFastAuth(); const { isLoggedIn } = useIsLoggedIn(); return isLoggedIn ? You're signed in 🎉 : ; } export default function App({ connection }) { return ( ); } ```

\~5 min Vanilla JS Vue Svelte

Framework-agnostic client

Use the class-based FastAuthClient in any web app to log users in and obtain a signer.

Start the quickstart → The FastAuthClient and FastAuthSigner classes. Which library fits your stack.

```ts main.ts theme={"theme":{"light":"github-light","dark":"github-dark"}} import { FastAuthClient } from "@fast-auth-near/browser-sdk"; import { JavascriptProvider } from "@fast-auth-near/javascript-provider"; import { connect } from "near-api-js"; const provider = new JavascriptProvider({ network: "mainnet", clientId: "", }); const { connection } = await connect({ networkId: "mainnet", nodeUrl: "https://rpc.mainnet.near.org", }); const client = new FastAuthClient(provider, connection, { fastAuthContractId: "fast-auth.near", mpcContractId: "v1.signer", }); await client.login(); const signer = await client.getSigner(); ```

\~10 min iOS Android

Native mobile login

Bring the same social login to iOS and Android with the React Native provider, backed by react-native-auth0.

Start the quickstart → Login, credentials, and signature requests on mobile.

```tsx App.tsx theme={"theme":{"light":"github-light","dark":"github-dark"}} import { Auth0Provider } from "react-native-auth0"; import { ReactNativeProvider } from "@fast-auth-near/react-native-provider"; const provider = new ReactNativeProvider({ network: "mainnet", clientId: "", }); export default function App() { return ( ); } // later, inside a component: await provider.login(); ```

Users sign in with Google, Apple, email, or passkeys through Auth0 — nothing to install, nothing to write down. Keys are never held by a single party. A Multi-Party Computation network produces every signature from distributed key shares. Each identity deterministically derives its own key, so the same login always controls the same NEAR account. A guard contract cryptographically verifies the Auth0 JWT on NEAR before any signature is produced. Sponsor gas via delegate actions, so users transact without holding NEAR. Ship on web, React, or React Native with typed SDKs and a handful of lines of code.

Pick the SDK for your framework and install it alongside the JavaScript (Auth0) provider. ```bash theme={"theme":{"light":"github-light","dark":"github-dark"}} npm install @fast-auth-near/react-sdk @fast-auth-near/javascript-provider near-api-js ``` Authenticate the user, get a signer, and request a signature for a NEAR transaction. A complete, copy-pasteable integration in under 5 minutes.

Mainnet requires approved credentials — [apply for production access](/home/apply) to get your Auth0 client ID.

Building locally? You can develop against testnet using the values in [Resources → Testnet](/resources/testnet).

What NEAR Auth is, quickstarts, integration guides, and going live. Contracts, JWT verification, the Auth0 flow, MPC signing, and advanced topics. Reference-style docs for every published library and provider. Deployed contract addresses and network config.