API

curl -X GET https://id.tokenpay.space/api/v1/users/me \
  -H "Authorization: Bearer tpid_sk_your_secret_key" \
  -H "Content-Type: application/json"

Authorization: Bearer tpid_sk_ваш_секретный_ключ

Authorization: Bearer eyJhbGciOiJSUzI1NiIs...

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 45
X-RateLimit-Reset: 1678886400

{
  "error": {
    "code": "invalid_token",
    "message": "The access token is invalid or expired",
    "status": 401
  }
}

https://id.tokenpay.space/api/v1/oauth/authorize?
  client_id=tpid_pk_your_public_key&
  redirect_uri=https://yourapp.com/callback&
  response_type=code&
  scope=profile email&
  state=random_csrf_token&
  prompt=login&
  code_challenge=SHA256_HASH&
  code_challenge_method=S256

curl -X POST https://id.tokenpay.space/api/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "authorization_code",
    "code": "abc123...",
    "client_id": "tpid_pk_...",
    "client_secret": "tpid_sk_...",
    "redirect_uri": "https://yourapp.com/callback",
    "code_verifier": "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"
  }'

{
  "access_token": "eyJhbGciOiJSUzI1NiIs...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "tpid_rt_8a7b6c5d...",
  "scope": "profile email",
  "user": {
    "id": "tpid_usr_a1b2c3d4",
    "email": "[email protected]",
    "name": "Иван",
    "email_verified": true
  }
}

curl -X GET https://tokenpay.space/api/v1/oauth/userinfo \
  -H "Authorization: Bearer ACCESS_TOKEN"

{
  "id": "tpid_usr_a1b2c3d4e5f6",
  "email": "[email protected]",
  "name": "Иван",
  "role": "user",
  "email_verified": true,
  "locale": "ru",
  "theme": "dark",
  "telegram_linked": true,
  "cupol_balance": 150,
  "cupol_subscription_active": true,
  "created_at": "2026-01-15T12:00:00Z"
}

{
  "provider": "TOKEN PAY ID",
  "widget_url": "https://tokenpay.space/sdk/tpid-widget.js",
  "widget_version": "1.2.0",
  "icon": { "shield_svg": "<svg ...>" },
  "buttons": {
    "standard": { "label": "Войти через TOKEN PAY", ... },
    "icon": { "shape": "circle", ... },
    "logo": { "background": "transparent", ... }
  },
  "integration": {
    "quick_start": "<script src=... data-client-id=...>",
    "oauth_popup": "TPID.loginWithOAuth().then(...);"
  },
  "themes": ["dark", "light", "auto"],
  "languages": ["ru", "en"]
}

{
  "client_id": "tpid_pk_...",
  "client_secret": "tpid_sk_...",
  "client_name": "My App",
  "redirect_uris": ["https://myapp.com/callback"],
  "client_type": "public",
  "registration_access_token": "Bearer ..."
}

{
  "client_id": "tpid_pk_...",
  "client_name": "My App",
  "client_type": "public",
  "redirect_uris": ["https://myapp.com/callback"],
  "client_uri": "https://myapp.com",
  "logo_uri": null,
  "tos_uri": null,
  "policy_uri": null,
  "scope": "openid,profile,email"
}

{
  "id": "tpid_usr_a1b2c3d4",
  "email": "[email protected]",
  "name": "Иван Чернов",
  "email_verified": true,
  "two_factor_enabled": false,
  "telegram_linked": true,
  "created_at": "2025-01-15T10:30:00Z",
  "last_login": "2026-03-13T09:45:00Z"
}

{
  "sessions": [
    {
      "id": "ses_abc123",
      "device": "Chrome — Windows",
      "ip": "192.168.1.1",
      "location": "Saint Petersburg, RU",
      "last_active": "2026-03-13T12:00:00Z",
      "current": true
    }
  ]
}

{
  "success": true,
  "message": "Verification code sent",
  "expires_in": 600
}

{
  "valid": true,
  "user_id": "tpid_usr_a1b2c3d4",
  "email": "[email protected]",
  "scopes": ["profile", "email"],
  "expires_at": 1678886400
}

{
  "requires_email_code": true,
  "requires_2fa": false,
  "message": "Verification code sent to your email"
}

{
  "sessionId": "uuid-...",
  "ttl": 300,
  "qrUrl": "https://tokenpay.space/qr-login?sid=uuid-..."
}

X-TPID-Signature: t=1711000000,v1=hmac_sha256_hex

const crypto = require('crypto');

function verifyWebhook(body, signature, secret) {
  const parts = {};
  signature.split(',').forEach(p => {
    const [k, v] = p.split('=');
    parts[k] = v;
  });
  const expected = crypto
    .createHmac('sha256', secret)
    .update(parts.t + '.' + JSON.stringify(body))
    .digest('hex');
  return parts.v1 === expected;
}

{
  "event": "user.login",
  "timestamp": "2026-03-13T12:00:00Z",
  "data": {
    "user_id": "tpid_usr_a1b2c3d4",
    "ip": "192.168.1.1",
    "device": "Chrome — Windows"
  }
}

{
  "notifications": [
    { "id": "...", "type": "oauth_connect", "title": "New user connected", "body": "[email protected] authorized via OAuth", "is_read": false, "created_at": "2026-04-02T12:00:00Z" }
  ],
  "unread": 3
}

const es = new EventSource('/api/v1/notifications/stream?token=' + token);
es.addEventListener('notification', e => {
  const data = JSON.parse(e.data);
  console.log(data.event, data.data.title);
});
es.addEventListener('connected', e => {
  console.log('SSE connected', JSON.parse(e.data));
});

<script src="https://tokenpay.space/sdk/tpid-widget.js"
        data-client-id="tpid_pk_ваш_ключ"></script>

<!-- Стандартная кнопка -->
<div data-tpid-button="standard"></div>

<!-- Круглая иконка -->
<div data-tpid-button="icon"></div>

<!-- Логотип без фона -->
<div data-tpid-button="logo"></div>

TPID.loginWithOAuth({ prompt: 'login' })
  .then(function(result) {
    console.log('Auth code:', result.code);
    console.log('State:', result.state);
    // Отправьте code на ваш сервер для обмена на токен
  })
  .catch(function(err) {
    console.error('OAuth error:', err);
  });

<!-- Прямоугольная кнопка с текстом -->
<script src="https://tokenpay.space/sdk/tpid-auth.js"
        data-client-id="tpid_pk_ваш_ключ"
        data-redirect-uri="https://ваш-сайт.com/callback"
        data-mode="logo"
        data-theme="dark"
        data-size="medium"
        data-lang="ru">
</script>

<!-- Круглая иконка -->
<script src="https://tokenpay.space/sdk/tpid-auth.js"
        data-client-id="tpid_pk_ваш_ключ"
        data-redirect-uri="https://ваш-сайт.com/callback"
        data-mode="icon"
        data-theme="light"
        data-size="large">
</script>

// Инициализация
TokenPayAuth.init({
  clientId: 'tpid_pk_ваш_ключ',
  redirectUri: 'https://ваш-сайт.com/callback',
  theme: 'dark',
  locale: 'ru',
  onSuccess: function(data) {
    console.log('Код:', data.code);
    console.log('Verifier:', data.codeVerifier);
    // Отправьте code + codeVerifier на ваш сервер
  }
});

// Рендер кнопки в контейнер
TokenPayAuth.renderButton('#my-container', {
  mode: 'button', // 'button' | 'icon'
  theme: 'dark',   // 'dark' | 'light' | 'auto'
  size: 'medium',  // 'small' | 'medium' | 'large'
  locale: 'ru'
});

// Или запуск OAuth вручную (PKCE генерируется автоматически)
TokenPayAuth.authorize();

// Получить code_verifier для серверного обмена
const verifier = TokenPayAuth.getCodeVerifier();

curl -X POST https://tokenpay.space/api/v1/oauth/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "authorization_code",
    "code": "tpid_code_...",
    "client_id": "tpid_pk_...",
    "client_secret": "tpid_sk_...",
    "redirect_uri": "https://ваш-сайт.com/callback",
    "code_verifier": "PKCE_VERIFIER"
  }'

curl -X GET https://tokenpay.space/api/v1/oauth/userinfo \
  -H "Authorization: Bearer ACCESS_TOKEN"

{
  "id": "tpid_usr_a1b2c3d4e5f6",
  "email": "[email protected]",
  "name": "Иван",
  "email_verified": true,
  "created_at": "2026-01-15T12:00:00Z"
}

pip install tokenpay-id

from tokenpay_id import TokenPayID

client = TokenPayID(
    client_id="tpid_pk_your_public_key",
    client_secret="tpid_sk_your_secret_key"
)

# Verify a user's token
result = client.verify(access_token)
print(result.user_id)  # tpid_usr_...

# Get user profile
user = client.get_user(access_token)
print(user.email)  # [email protected]

# Webhook signature verification
is_valid = client.verify_webhook(
    payload=request.body,
    signature=request.headers["X-TPID-Signature"]
)

go get github.com/tokenpay/id-go

package main

import (
    tpid "github.com/tokenpay/id-go"
)

func main() {
    client := tpid.NewClient(tpid.Config{
        ClientID:     "tpid_pk_your_public_key",
        ClientSecret: "tpid_sk_your_secret_key",
    })

    // Verify token
    result, err := client.Verify(accessToken)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(result.UserID) // tpid_usr_...
}

implementation("space.tokenpay:id-sdk:2.2.0")

import space.tokenpay.id.TokenPayID

val client = TokenPayID(
    clientId = "tpid_pk_your_public_key",
    clientSecret = "tpid_sk_your_secret_key",
    redirectUri = "myapp://callback"
)

// OAuth — открыть браузер
val authUrl = client.getAuthorizationUrl(
    scopes = listOf("profile", "email"),
    usePKCE = true
)
startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(authUrl)))

// Обработка callback в Activity
override fun onNewIntent(intent: Intent) {
    val code = intent.data?.getQueryParameter("code") ?: return
    lifecycleScope.launch {
        val tokens = client.exchangeCode(code)
        val user = client.getUserInfo(tokens.accessToken)
        Log.d("TPID", "User: ${user.name} (${user.email})")
    }
}

// Верификация токена на сервере
val result = client.verify(accessToken)
println(result.userId) // tpid_usr_...

.package(url: "https://github.com/tokenpay/id-swift", from: "2.2.0")

import TokenPayID

let client = TPIDClient(
    clientId: "tpid_pk_your_public_key",
    clientSecret: "tpid_sk_your_secret_key",
    redirectURI: "myapp://callback"
)

// OAuth через ASWebAuthenticationSession
let authURL = client.authorizationURL(scopes: [.profile, .email], usePKCE: true)

let session = ASWebAuthenticationSession(
    url: authURL,
    callbackURLScheme: "myapp"
) { callbackURL, error in
    guard let code = callbackURL?.queryParam("code") else { return }
    Task {
        let tokens = try await client.exchangeCode(code)
        let user = try await client.userInfo(tokens.accessToken)
        print("User: \(user.name) — \(user.email)")
    }
}
session.start()

dotnet add package TokenPayID --version 2.2.0

using TokenPayID;

var client = new TPIDClient(
    clientId: "tpid_pk_your_public_key",
    clientSecret: "tpid_sk_your_secret_key",
    redirectUri: "https://yourapp.com/callback"
);

// Генерация OAuth URL (с PKCE)
var (authUrl, verifier) = client.GetAuthorizationUrl(
    scopes: new[] { "profile", "email" },
    usePKCE: true
);

// Обмен кода на токены
var tokens = await client.ExchangeCodeAsync(code, verifier);
var user = await client.GetUserInfoAsync(tokens.AccessToken);
Console.WriteLine($"User: {user.Name} ({user.Email})");

// ASP.NET — middleware
services.AddAuthentication()
    .AddTokenPayID(options => {
        options.ClientId = "tpid_pk_...";
        options.ClientSecret = "tpid_sk_...";
    });

composer require tokenpay/id-php

use TokenPay\ID\Client;

$client = new Client([
    'client_id'     => 'tpid_pk_your_public_key',
    'client_secret' => 'tpid_sk_your_secret_key',
    'redirect_uri'  => 'https://yourapp.com/callback',
]);

// Редирект на авторизацию (с PKCE)
[$authUrl, $verifier] = $client->getAuthorizationUrl(['profile', 'email']);
$_SESSION['tpid_verifier'] = $verifier;
header("Location: $authUrl");

// Callback — обмен кода
$tokens = $client->exchangeCode($_GET['code'], $_SESSION['tpid_verifier']);
$user = $client->getUserInfo($tokens->access_token);
echo "Hello, {$user->name}!";

// Laravel — встроенный Socialite драйвер
// config/services.php
'tokenpay' => [
    'client_id' => env('TPID_CLIENT_ID'),
    'client_secret' => env('TPID_CLIENT_SECRET'),
    'redirect' => '/auth/tokenpay/callback',
]

gem 'tokenpay-id', '~> 2.2'

require 'tokenpay/id'

client = TokenPay::ID::Client.new(
  client_id: 'tpid_pk_your_public_key',
  client_secret: 'tpid_sk_your_secret_key',
  redirect_uri: 'https://yourapp.com/callback'
)

# OAuth URL
auth_url, verifier = client.authorization_url(
  scopes: ['profile', 'email'],
  pkce: true
)

# Обмен кода
tokens = client.exchange_code(params[:code], verifier)
user = client.user_info(tokens.access_token)
puts "#{user.name} (#{user.email})"

# Rails — OmniAuth стратегия
Rails.application.config.middleware.use OmniAuth::Builder do
  provider :tokenpay_id,
    ENV['TPID_CLIENT_ID'],
    ENV['TPID_CLIENT_SECRET']
end

dependencies:
  tokenpay_id: ^2.2.0

import 'package:tokenpay_id/tokenpay_id.dart';

final client = TPIDClient(
  clientId: 'tpid_pk_your_public_key',
  clientSecret: 'tpid_sk_your_secret_key',
  redirectUri: 'myapp://callback',
);

// Flutter — OAuth через url_launcher
final authUrl = client.getAuthorizationUrl(
  scopes: ['profile', 'email'],
  usePKCE: true,
);
await launchUrl(Uri.parse(authUrl));

// Обработка deep link
void handleCallback(Uri uri) async {
  final code = uri.queryParameters['code']!;
  final tokens = await client.exchangeCode(code);
  final user = await client.getUserInfo(tokens.accessToken);
  print('Hello, ${user.name}!');
}

[dependencies]
tokenpay-id = "2.2"

use tokenpay_id::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new(
        "tpid_pk_your_public_key",
        "tpid_sk_your_secret_key",
    );

    // Верификация токена
    let result = client.verify(access_token).await?;
    println!("User: {}", result.user_id);

    // OAuth URL с PKCE
    let (auth_url, verifier) = client.authorization_url(
        &["profile", "email"],
        "https://yourapp.com/callback",
    )?;

    // Обмен кода
    let tokens = client.exchange_code(code, &verifier).await?;
    let user = client.user_info(&tokens.access_token).await?;
    println!("{} ({})", user.name, user.email);

    Ok(())
}

GET https://tokenpay.space/api/v1/oauth/authorize
  ?client_id=tpid_pk_...
  &redirect_uri=myapp://callback     // custom scheme
  &response_type=code
  &scope=profile email
  &state=RANDOM_STATE
  &code_challenge=BASE64URL(SHA256(verifier))
  &code_challenge_method=S256
  &theme=dark                         // dark | light — match app theme
  &lang=ru                            // ru | en | zh — UI language

const { app } = require('electron');

// Регистрация custom protocol
app.setAsDefaultProtocolClient('myapp');

// Обработка deep link (Windows/Linux)
app.on('second-instance', (event, argv) => {
  const url = argv.find(a => a.startsWith('myapp://'));
  if (url) handleOAuthCallback(url);
});

// Обработка deep link (macOS)
app.on('open-url', (event, url) => {
  event.preventDefault();
  handleOAuthCallback(url);
});

async function handleOAuthCallback(url) {
  const { searchParams } = new URL(url);
  const code = searchParams.get('code');
  const state = searchParams.get('state');
  // Обменяйте code на токены через API
}

// src-tauri/tauri.conf.json
{
  "plugins": {
    "deep-link": {
      "desktop": { "schemes": ["myapp"] },
      "mobile": [
        { "host": "callback", "pathPrefix": "/" }
      ]
    }
  }
}

// Frontend (TypeScript)
import { onOpenUrl } from '@tauri-apps/plugin-deep-link';

onOpenUrl((urls) => {
  const url = new URL(urls[0]);
  const code = url.searchParams.get('code');
  // Exchange code for tokens
});