Integration flow overview
Last updated
Last updated
Welcome to the Oten IDP Developer Integration Guide! This page provides a comprehensive overview of the entire integration process, giving you a roadmap before diving into the detailed implementation steps.
This overview covers:
Complete integration workflow from setup to production
Step-by-step roadmap with clear milestones
JAR (JWT-Secured Authorization Request) requirements - CRITICAL for Oten IDP
Different client types and their specific implementation paths
Security considerations and best practices
Testing and deployment strategies
CRITICAL: Oten IDP requires JAR (JWT-Secured Authorization Request) for ALL authorization requests.
Key Points:
❌ Traditional OAuth query parameters are REJECTED
✅ All OAuth parameters must be in a signed JWT
Choose HS256 (client secret) or EdDSA (key pair)
For complete JAR details, see JAR Requirement
Here's your complete journey from start to finish:
Total Estimated Time: 3-4 hours for basic implementation
Choose your path based on what you're building:
Examples: Traditional websites, admin panels, internal tools
Go to: Server-Side Integration Guide
Examples: React app, Vue app, Angular app (no backend)
You Need: A small backend service to handle JAR creation Go to: SPA Integration Guide
Examples: iOS app, Android app, React Native
You Need: Backend service + deep link setup Go to: Mobile Integration Guide
Oten requires signed requests for security. Choose your signing method:
For beginners and development
How it works: Use your client secret (password) to sign requests
For production and public apps
How it works: Generate a key pair, keep private key secret, register public key
Start with Go + Client Secret method
Use EdDSA for better security
Question 1: Is this for production?
Question 2: Do you have a backend server?
Simple 5-step process:
Result: User is logged in and can use your app!
Choose your path:
Go with Client Secret - Easiest path, 1-2 hours
Choose Your Library - More setup needed, 2-4 hours
Key Pairs Setup - Most secure, requires key management
Next: Step 1: Choose OAuth Library
Setup
Prerequisites
Environment setup, Oten registration
30 minutes
JAR
JAR Requirement
CRITICAL: Understanding JAR requirements
15 minutes
Library
Choose OAuth Library
Select JAR-compatible library
20 minutes
Config
Configure Client
Set up OAuth client with JAR
30 minutes
Auth
Authorization Flow
Implement JAR authorization
45 minutes
Callback
Handle Callback
Process OAuth callback
30 minutes
Tokens
Token Management
Secure token storage & refresh
45 minutes
Backend server (Node.js, Python, Go, etc.)
✅ Easiest path
Database for user sessions
✅ Store secrets securely
Server-side rendering
✅ Full control over auth
Frontend framework only
❌ More complex
No backend server
⚠️ Need backend service for JAR
Browser-based app
⚠️ Cannot store secrets safely
Mobile application
❌ Most complex
App store distribution
⚠️ Need backend service for JAR
Native or hybrid app
⚠️ Deep link handling required
✅ Simple setup
❌ Less secure
Development
✅ No key management
❌ Shared secret
Internal apps
✅ Quick to implement
Getting started
✅ Very secure
❌ More complex setup
Production
✅ No shared secrets
❌ Key management needed
Public apps
✅ Industry standard
High security
✅ We provide ready-made library
✅ Simpler to implement
✅ Built-in JAR support
✅ No key management
✅ Complete examples
✅ Works for most cases
✅ 1-2 hours to implement
✅ Good for learning
🟡 Good
HS256
Internal tools, development
🟢 Better
EdDSA
Production, public apps
No → Use Client Secret method
Yes → Continue to Question 2
Yes → Use Key Pairs method
No → You need to build a small backend service first
1️⃣
User clicks "Login"
User
2️⃣
App creates signed request (JAR)
Your app
3️⃣
User enters password at Oten
User
4️⃣
Oten sends back a code
Oten
5️⃣
App exchanges code for tokens
Your app
Sign requests with your client secret
Handle the callback when user returns
Store tokens safely
Use tokens for API calls
Generate key pair (one time setup)
Register public key with Oten
Sign requests with private key
Handle the callback when user returns
Store tokens safely
Use tokens for API calls