This repository houses community-contributed integrations, SDKs, middleware, and tools that extend APort's capabilities across different platforms, frameworks, and use cases. Each integration demonstrates how to implement APort's agent identity verification and policy enforcement in real-world scenarios.

• 🆔 Agent Identity: Portable passports with capabilities & limits
• 📋 Policy Packs: Pre-built policies for common actions (refunds, data export, PR merges)
• ⚡ Real-time Verify: Sub-100ms policy checks with global suspend capability
• 🔐 Multi-level Assurance: Email, GitHub, Domain verification levels
• 🌐 Platform Agnostic: Works across all platforms and frameworks

The official APort SDKs are maintained in the aport-sdks repository.

• Core SDK: @aporthq/sdk-node - Core Node.js SDK
• Express Middleware: @aporthq/middleware-express - Express.js middleware

• Core SDK: aporthq-sdk-python - Core Python SDK
• FastAPI Middleware: agent-passport-middleware-fastapi - FastAPI middleware

We're actively building more SDKs and integrations! Check out our open issues to contribute:

• Go SDK - Core Go SDK with Gin, Echo, Fiber middleware
• PHP SDK - Core PHP SDK with Laravel middleware
• Ruby SDK - Core Ruby SDK with Rails gem

• LangChain Integration - Tool guard for LangChain
• CrewAI Integration - Task verification decorator
• n8n Workflow Node - Custom n8n node for policy checks

• Zapier App - Custom Zapier app for APort verification
• GitHub App - PR/Merge verification
• Discord Bot - Team verification workflows

• VS Code Extension - Code snippets and syntax highlighting
• Postman Collection - API testing and CI/CD integration
• CLI Tool - Quick integration setup

• Shopify App - Refund protection for e-commerce
• Stripe Integration - Payment verification
• Banking APIs - Financial services integration

• OpenAPI Spec - OpenAPI 3.1 specification for APort API
• AP2 Bridge - AP2 payment authorization bridge
• SPIFFE/SPIRE - Enterprise identity integration

We're actively building the APort ecosystem with 22+ open issues and 6 issues already picked up by contributors!

• Total Issues: 22 open issues
• Issues Picked Up: 6 (27% pickup rate in 8 hours!)
• Total Bounty Pool: $175+ USD
• Categories: 10+ different integration types

1. Blog Post Tutorial - 2 assignees
2. n8n Workflow Node - 1 assignee
3. Go SDK - 1 assignee
4. Next.js Middleware - 2 assignees
5. AP2 Payment Bridge - 2 assignees
6. Zapier Custom App - 1 assignee

• LangChain: Most popular AI framework - needs tool guard integration
• CrewAI: Multi-agent orchestration - needs task verification decorator
• n8n: Low-code automation - needs custom verification node
• LangGraph: State machine workflows - needs checkpoint integration
• Zapier: No-code automation - needs custom app

• Shopify: Complete app with refund guardrails
• WooCommerce: WordPress plugin for order verification
• Stripe: Connect payout verification

• CLI Tool: npx create-aport-integration scaffolding
• VS Code Extension: Policy development with IntelliSense
• Postman Collection: Complete API testing suite

• Next.js: App Router and Pages Router support
• Django: Python web framework middleware
• Laravel: PHP framework with Artisan commands
• Rails: Ruby gem with generators
• Go Frameworks: Gin, Echo, Fiber middleware

• OpenAPI 3.1: Complete API specification
• AP2 Bridge: Payment authorization integration
• SPIFFE/SPIRE: Enterprise identity federation

# Clone the repository
git clone https://github.com/aporthq/aport-integrations.git
cd aport-integrations

# Explore integrations by category
ls examples/
# agent-frameworks/  ecommerce/  developer-tools/  middleware/  protocol-bridges/

# Example: LangChain Tool Guard
cd examples/agent-frameworks/langchain
npm install
npm run example

# Example: Express.js Middleware
cd examples/middleware/express
npm install
npm start

# Use our CLI to scaffold a new integration
npx create-aport-integration my-integration
cd my-integration
npm install

aport-integrations/
├── examples/                    # Working integration examples
│   ├── agent-frameworks/        # LangChain, CrewAI, n8n, etc.
│   ├── ecommerce/              # Shopify, WooCommerce, Stripe
│   ├── middleware/             # Express, FastAPI, Django, etc.
│   └── protocol-bridges/       # OpenAPI, AP2, SPIFFE/SPIRE
├── tools/                      # Developer tools and utilities
│   ├── cli/                    # APort CLI for scaffolding
│   ├── vscode-extension/       # VS Code extension
│   └── postman-collection/     # Postman collection
├── templates/                  # Integration scaffolding templates
│   ├── javascript-middleware/  # Express.js template
│   └── python-middleware/      # FastAPI template
├── sdk/                        # References to official SDKs
│   └── README.md               # Links to aport-sdks repository
└── docs/                       # Integration documentation

• examples/ - Working integration examples that demonstrate real-world usage of APort
• tools/ - Developer tools and utilities (CLI, VS Code extension, Postman collection)
• templates/ - Scaffolding templates for quick integration development and consistent structure
• sdk/ - References to official APort SDKs maintained in the aport-sdks repository

Make APort the default trust layer for AI agent frameworks.

Prove the refund use case with working platform integrations.

Reduce APort integration time from hours to minutes.

Position APort as the universal verify layer.

Native support for popular web frameworks.

// Express.js with APort middleware
const { createAPortMiddleware } = require("@aporthq/middleware-express");

const aportMiddleware = createAPortMiddleware({
  apiKey: process.env.APORT_API_KEY
});

app.post("/api/refunds", 
  aportMiddleware("finance.payment.refund.v1"),
  async (req, res) => {
    // Policy already verified! Check specific limits
    const passport = req.aport.passport;
    
    if (req.body.amount > passport.limits.refund_amount_max_per_tx) {
      return res.status(403).json({
        error: "Refund exceeds limit",
        requested: req.body.amount,
        limit: passport.limits.refund_amount_max_per_tx
      });
    }

    // Process refund safely
    const refund = await stripe.refunds.create({
      amount: req.body.amount,
      payment_intent: req.body.payment_intent
    });
    
    res.json({ success: true, refund });
  }
);

# LangChain with APort Tool Guard
from aporthq_sdk import APortClient
from langchain.tools import Tool

def refund_tool(order_id: str, amount: float) -> str:
    return f"Refunded ${amount} for order {order_id}"

# Initialize APort client
aport_client = APortClient(api_key=os.getenv("APORT_API_KEY"))

# Create protected tool wrapper
class APortToolGuard:
    def __init__(self, tool, policy_pack, agent_id):
        self.tool = tool
        self.policy_pack = policy_pack
        self.agent_id = agent_id
    
    async def __call__(self, *args, **kwargs):
        # Verify agent before tool execution
        result = await aport_client.verify(self.policy_pack, self.agent_id)
        if not result.verified:
            raise Exception("Agent verification failed")
        
        # Execute tool if verified
        return self.tool(*args, **kwargs)

# Wrap tool with APort verification
protected_refund_tool = APortToolGuard(
    tool=Tool(
        name="refund_tool",
        description="Process customer refunds",
        func=refund_tool
    ),
    policy_pack="finance.payment.refund.v1",
    agent_id="agt_inst_xyz789"
)

# Use in agent
agent = initialize_agent([protected_refund_tool], llm, agent_type="zero-shot-react-description")

# .github/workflows/aport-verify.yml
name: APort Verify PR
on: [pull_request]

jobs:
  verify:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: aporthq/policy-verify-action@v1
        with:
          agent-id: ${{ secrets.APORT_AGENT_ID }}
          policy-pack: 'code.repository.merge.v1'
          context: |
            {
              "repo": "${{ github.repository }}",
              "base": "${{ github.event.pull_request.base.ref }}",
              "head": "${{ github.event.pull_request.head.ref }}",
              "files_changed": ${{ toJson(github.event.pull_request.changed_files) }}
            }

We're participating in Hacktoberfest 2025! Join us in building the future of AI agent security.

• 💰 Bounties: $15-$50 per merged PR
• 👕 Swag: APort Champion T-shirts for contributors
• 🏆 Grand Prizes: Up to $150 for exceptional contributions
• 🌟 Recognition: Featured on our website and social media

1. Fork this repository
2. Browse open issues labeled hacktoberfest
3. Claim an issue by commenting "I'd like to work on this"
4. Build your integration following our contribution guidelines
5. Submit a pull request with your implementation
6. Get paid via Chimoney when your PR is merged!

• LangChain Tool Guard - $50
• CrewAI Task Decorator - $50
• Shopify Refund Guardrail - $50
• APort CLI Tool - $50

View all Hacktoberfest issues →

1. "Good First Issue" Label - 4/6 picked issues have this label
2. Content Creation - Blog posts and tutorials are highly attractive
3. Integration & Middleware - 5/6 issues are integration-related
4. Automation Tools - n8n and Zapier appeal to no-code audience
5. Financial Use Cases - Payment/AP2 bridge resonates strongly

• Use good-first-issue label for beginner-friendly tasks
• Focus on content creation and developer experience
• Target specific frameworks (Next.js, Go, n8n, Zapier)
• Include clear success criteria and bounty amounts
• Provide scaffolding templates for complex integrations

We love contributions! Whether you're fixing bugs, adding features, or creating new integrations, your work helps make APort better for everyone.

1. Browse Issues: Check our open Hacktoberfest issues
2. Use Templates: Copy scaffolding templates from /templates/ directory
3. Follow Guidelines: See CONTRIBUTING.md for detailed instructions
4. Get Rewarded: Earn $5-$40 USD per completed issue!

• Agent Framework Integrations (LangChain, CrewAI, n8n)
• Platform Integrations (Zapier, GitHub, Discord)
• Developer Experience (VS Code, CLI, Postman)
• Content Creation (Tutorials, blog posts, videos)

• ✅ Working Example: Must include a complete, runnable example
• ✅ Documentation: Clear README with setup instructions
• ✅ Tests: Unit tests for core functionality
• ✅ Error Handling: Graceful failure modes
• ✅ Security: No hardcoded secrets or credentials

• Language-specific: Follow standard conventions (ESLint, Black, gofmt)
• Documentation: Include docstrings and comments
• Testing: Minimum 80% code coverage
• Security: Use environment variables for secrets

Read our full Contributing Guide →

• 📖 Core Features - Complete list of APort Features
• 📖 Documentation - Complete guides and API reference
• 🎮 Swagger Documentation - Try APort in your browser
• 💡 Examples - Real-world implementations

• API Reference - Complete API documentation
• Policy Packs - Pre-built policy definitions
• SDKs - Language-specific SDKs
• Specification - AI Passport Specification
• GitHub Actions - CI/CD integrations

• GitHub Discussions - Ask questions

This project is licensed under the MIT License - see the LICENSE file for details.