vLoading... 200+ Downloads

Layered Authentication for Modern APIs

KeypointJS is a sophisticated, layered authentication and authorization framework for Node.js with built-in security features, plugin architecture, and real-time capabilities.

8-Layer Security

Multi-layered protection

Lightweight

~140KB gzipped

Plugin System

Extensible architecture

Get Started View on GitHub Read Docs

Install with npm

npm install keypointjs

Why KeypointJS?

Built for security, designed for developers

Layered Security

8-layer middleware system for comprehensive API protection and threat mitigation.

Plugin Architecture

Extensible with custom plugins. Built-in Audit Logger, Rate Limiter, and WebSocket Guard.

High Performance

Built-in HTTP server with zero dependencies. No Express or Fastify required.

WebSocket Support

Real-time communication with built-in authentication and connection management.

Policy Engine

Rule-based access control with IP whitelisting, rate limiting, and time-based rules.

Multiple Storage

Choose between in-memory, file-based, or implement your own storage backend.

8-Layer Architecture

How KeypointJS processes every request

Pre-processing Hooks

Request preprocessing and validation

Protocol Engine

HTTP/HTTPS/WebSocket detection & parsing

CORS Middleware

Cross-origin resource sharing handling

Keypoint Validation

Authentication and keypoint verification

Policy Check

Authorization rules evaluation

Plugin Processing

Plugin middleware execution

Route Execution

Business logic processing

Response Processing

Response formatting and sending

Get Started in 60 Seconds

Start securing your API with just a few lines of code

Basic Setup

import { KeypointJS } from 'keypointjs';

// Initialize the framework
const api = new KeypointJS({
  requireKeypoint: true,
  strictMode: false,
  enableCORS: true,
  maxRequestSize: '5mb'
});

// Create and store a keypoint
const keypoint = await api.createKeypoint({
  keyId: 'test_key',
  secret: 'test_secret',
  scopes: ['api:public', 'users:read'],
  protocols: ['https', 'wss'],
  allowedOrigins: ['https://example.com'],
  rateLimit: {
    requests: 1000,
    window: 3600 // 1 hour
  }
});

// Define protected route
api.get('/api/data', (ctx) => {
  return ctx.json({
    data: 'protected data',
    keypointId: ctx.getKeypointId(),
    scopes: ctx.keypoint?.scopes
  });
});

// Start server
api.listen(3000, 'localhost', () => {
  console.log('KeypointJS server running on port 3000');
});

Total Downloads

GitHub Stars

Forks

v1.0.0

Latest Version

Comprehensive Documentation

Everything you need to build secure applications

API Reference

Complete API documentation with examples

Plugins Guide

Built-in plugins and custom plugin creation

Security Best Practices

Production-ready security configurations

Deployment Guide

Docker, Kubernetes, and cloud deployment

Examples & Tutorials

Real-world use cases and tutorials

Migration Guide

Migrating from other authentication solutions

Real-World Examples

See KeypointJS in action

WebSocket Authentication

// Enable WebSocket support
const wsGuard = api.enableWebSocket({
  path: '/ws',
  requireKeypoint: true,
  pingInterval: 30000,
  maxConnections: 1000
});

// Handle new connections
wsGuard.onConnection((connection) => {
  console.log('New WebSocket connection:', connection.id);
});

// Handle messages with authentication
wsGuard.onMessage('chat', (message, connection) => {
  if (!connection.scopes?.includes('chat:write')) {
    return { type: 'error', error: 'Insufficient scope' };
  }
  
  // Broadcast to all connections
  wsGuard.broadcast({
    type: 'chat',
    from: connection.keypointId,
    message: message.text,
    timestamp: new Date().toISOString()
  });
  
  return { type: 'ack', success: true };
});