Results for “endpoint”

Build and deploy a paid API that other agents can pay to use via x402. Use when you or the user want to monetize an API, make money, earn money, offer a service, sell a service to other agents, charge for endpoints, create a paid endpoint, or set up a paid service. Covers "make money by offering an endpoint", "sell a service", "monetize your data", "create a paid API".

The English summary is being prepared. Showing the original description.

Build FastAPI endpoints in the layered router → service → Supabase pattern, with Pydantic v2 schemas, JWT/admin gating, and consistent HTTPException-based domain errors. Use when adding/modifying any endpoint under backend/.

The English summary is being prepared. Showing the original description.

Clarify the availability and requirements of model serving on booked Itô GPUs. The supplied implementation does not support serving, so it reports that limitation and documents future booking verification, configuration review, and explicit confirmation requirements.

• Checking documented serving availability after an Itô GPU booking
• Clarifying limitations for an OpenAI-compatible endpoint
• Reviewing future model-serving configuration requirements

Design APIs and interfaces between modules with clear inputs, outputs, naming, and errors. The skill guides compatible extensions, input validation, and retry handling so callers can use interfaces consistently without accidentally repeating state-changing operations.

• Designing new REST endpoints
• Defining frontend and backend data contracts
• Extending an API while preserving compatibility

Build or modify adapters that connect Paperclip to AI agent runtimes. Covers server execution, configuration forms, terminal output, session persistence, and environment checks for CLI agents, HTTP endpoints, and custom processes.

• Connect a new CLI agent to Paperclip
• Add support for an HTTP agent endpoint
• Implement session resumption and recovery

Generate images and videos using AI models on fal.ai. The skill covers Flux, SDXL, ideogram, and other community-hosted model endpoints, providing an entry point for requesting generation through an agent.

• Requesting image generation through fal.ai
• Requesting video generation through fal.ai
• Specifying Flux, SDXL, or ideogram for image generation

Register and manage webhook endpoints, which receive event notifications from OmniRoute. Choose events such as completed requests or exceeded quotas, test delivery, inspect delivery history, and manage retries when notifications need another attempt.

• Set up notifications for completed or failed requests
• Configure quota exceeded notifications
• Validate and test notification destinations

Manage OmniRoute API keys by creating, listing, rotating, and revoking them. Set access permissions, allowed models, spending limits, and expiration dates for each key to control access to proxy and management endpoints.

• Create API keys with limited permissions
• Rotate or revoke existing keys
• Set spending limits and expiration dates

Prepare a node to participate in federation, a setup connecting multiple nodes. Generate an ed25519 keypair and configuration, optionally set a compliance mode, and display the public key and endpoint to share with peers.

• Initialize a node for federation
• Set a compliance mode during initial setup
• Check the public key and endpoint to share with peers

Generate API documentation from TypeScript and JavaScript source code. Extract JSDoc comments, fill gaps in public API descriptions, and produce OpenAPI 3.0 definitions, a standard format for describing HTTP endpoints.

• Document public functions, classes, and interfaces
• Fill gaps in JSDoc comments
• Generate OpenAPI 3.0 definitions for HTTP endpoints

Review HTML forms and JavaScript requests to find data sent over unencrypted HTTP. Check submission URLs, pages with implicit form destinations, and server redirects, then update endpoints to use HTTPS.

• Checking login form submission URLs
• Reviewing fetch() and XMLHttpRequest endpoints
• Checking forms without an action attribute

Test REST, GraphQL, and gRPC APIs with Strix using schemas, credentials, and example data. Investigate authorization flaws, excessive data exposure, and other API risks, then verify findings with requests that reproduce the issue.

• Testing an API from its specification
• Checking data access across tenants
• Verifying restrictions on administrator routes

Combine laboratory animal welfare measurements into reference-relative RELSA severity scores. Analyze individual trajectories, explore forecasts for specified observation times, and derive candidate score zones, with explicit checks on normalization, reference selection, prediction intervals, and evaluation limits.

• Combine animal welfare measurements into daily scores
• Compare group severity using a shared reference
• Explore severity forecasts at specified observation times

Helps build LabArchives connections for electronic lab notebooks and laboratory inventory. Guides endpoint selection, request signing for authentication, and user authorization, with local tools to inspect container files and prepare redacted request plans before remote operations.

• Plan an electronic lab notebook API connection
• Check authentication for laboratory inventory requests
• Inspect an LA container file locally

Design APIs and interfaces between parts of an application with clear input and output types, consistent errors, and predictable names. The guidance helps you extend existing interfaces while preserving compatibility for the code that uses them.

• Designing new REST or GraphQL endpoints
• Defining contracts between frontend and backend
• Reviewing changes to a public interface

Trace server-side request forgery, where a server fetches a supplied URL, through internal services and metadata endpoints in a CTF sandbox. Document credential scope and distinguish successful token extraction from access actually accepted by another service.

• Tracing server-side requests to internal services
• Checking metadata access and token scope
• Distinguishing token extraction from accepted access

Set up Python APIs with FastAPI using organized project templates. Build routes, asynchronous database operations, authentication, and error handling, with examples for sharing dependencies and testing endpoints through a separate test database.

• Set up a new FastAPI project
• Build a Python API with asynchronous database access
• Organize authentication and shared dependencies

Explore the context-matic MCP server through an interactive tour. Discover available APIs, choose one, and review authentication, data structures, and example calls in your project's programming language, with guidance matched to the SDK version.

• Learning what the context-matic server can do
• Browsing APIs available for a project's language
• Exploring an API's authentication and quickstart

Compare C# Web API source code with its TypeScript or JavaScript clients to find mismatched data fields, required inputs, and response handling. Receive an audit report showing client impact, severity, and confidence in each match.

• Check client impact before merging a DTO or controller change
• Audit API compatibility before a release
• Find stale request fields and missing response fields

Detect attacks that misuse legitimate Windows utilities such as certutil and mshta. Analyze process logs, command arguments, and parent-child relationships with Sigma detection rules, then report suspicious events with severity scores and supporting event details.

• Investigating suspicious use of built-in Windows utilities
• Creating Sigma rules for unusual command arguments
• Finding Office apps that launch unexpected system utilities

Use CloudFox to inspect AWS and Azure resources through read-only queries. Identify exposed endpoints, secrets, permissions, and role trust relationships, then organize findings into files for reviewing configuration weaknesses and potential paths to broader access.

• Inventorying an unfamiliar AWS or Azure account
• Finding internet-facing resources
• Mapping role trust relationships and permissions

Investigate service account misuse by examining unexpected interactive logons, privilege changes, and movement between systems. Correlate endpoint and security logs, distinguish suspicious activity from legitimate operations, and document evidence, risk, and recommended responses.

• Investigating unexpected interactive logons by service accounts
• Checking service account access outside its assigned scope
• Tracing suspicious movement between systems after hours

Detect attacks that misuse legitimate Windows tools by examining command arguments, parent and child processes, and network connections. Create Sysmon logging configurations and Sigma detection rules, analyze endpoint logs, and review application controls while accounting for legitimate usage.

• Creating detection rules for misuse of Windows tools
• Investigating unusual process chains in alerts
• Hunting for fileless attacks in endpoint logs

Investigate Windows credential theft by correlating endpoint monitoring data, Sysmon events, and security logs. The skill provides detection queries and a reporting format to identify suspicious access and assess which credentials may be compromised.

• Investigating alerts about suspicious LSASS access
• Hunting for credential theft across Windows systems
• Assessing the scope of potentially compromised credentials