canonical: https://jentic.com/apis/archtools.dev/archtools

# Arch Tools API

Jentic publishes the only available OpenAPI specification for Arch Tools API, keeping it validated and agent-ready. Arch Tools provides 61 production-ready API tools designed for AI agents and developers, bundling utilities that would otherwise require integrating many vendor APIs. The catalogue covers web scraping, AI text and image generation, audio transcription, crypto market data, email and domain checks, research, video generation, QR code creation, hashing, and format conversion. Authentication is via an API key, with operations grouped by category tags including AI, Audio, Communication, Crypto, Image, Utility, and Web.

## For AI agents

Call a single API to scrape pages, transcribe audio, generate images, convert formats, hash data, and run dozens of other agent utility operations.

## Scope

Does not handle long-running model training, persistent storage, or full-stack hosting - use for one-shot utility calls and content transformations only.

## Capabilities

- Scrape any public URL with optional CSS selector targeting
- Validate JSON payloads against a JSON Schema before downstream use
- Convert documents between JSON, YAML, CSV, and XML formats
- Generate cryptographic hashes (SHA-256, SHA-512, MD5) over arbitrary input
- Extract clean text, links, and OG metadata from a webpage or raw text
- Generate QR codes as PNG or SVG and transform text across 10 modes
- Bundle web, AI, audio, image, and crypto utilities behind one API key

## Use cases

### Agent Utility Toolbelt

Give an AI agent a single integration that covers the long tail of utility operations it would otherwise need a dozen vendors for. Builders use Arch Tools to keep agent dependency graphs simple - one API key, one auth scheme, one rate-limit budget. The 61 endpoints cover hashing, format conversion, scraping, validation, QR codes, and more behind a consistent shape.

Example prompt: Pick the appropriate Arch Tools endpoint for the user's request - for example POST `/v1/tools/web-scrape` - and execute with the user-supplied URL and selector.

### Content Extraction Pipeline

Build a pipeline that ingests URLs, extracts clean text, and pulls out metadata for downstream summarisation or classification. Research and content-aggregation tools use Arch Tools to skip wiring their own scraping and metadata extraction layer. POST `/v1/tools/extract-page` returns clean text, links, and metadata in a single call.

Example prompt: Call POST `/v1/tools/extract-page` with the URL and return the extracted text and OG metadata for downstream processing.

### Format Conversion at the Edge of the Pipeline

Convert between common data interchange formats without bundling a parsing library into the agent runtime. Data engineers use Arch Tools to handle ad-hoc CSV-to-JSON or YAML-to-JSON conversions inside agent flows where pulling in pandas would be overkill. POST `/v1/tools/convert-format` accepts the source format, target format, and payload.

Example prompt: Call POST `/v1/tools/convert-format` with from='csv', to='json', and the user's CSV body, then return the JSON output.

### Validation and Hashing in Agent Flows

Validate inputs and generate cryptographic hashes inside an agent workflow without standing up dedicated services. Developer agents and automation flows use Arch Tools to verify JSON payloads against a schema and to fingerprint content for deduplication. The validate-data and generate-hash endpoints handle each step in isolation.

Example prompt: Call POST `/v1/tools/validate-data` with the schema and instance, then call POST `/v1/tools/generate-hash` with the instance to produce a SHA-256 fingerprint.

### AI Agent Multi-Tool via Jentic

An agent that needs many small utilities can route them all through Arch Tools via Jentic, getting one credential and one schema-driven entry point. Jentic's intent search exposes each Arch Tools operation as a discoverable tool the agent can invoke without prior knowledge of the catalogue. Credentials stay in your Jentic One instance.

Example prompt: Use Jentic search 'scrape a web page' to find Arch Tools' web-scrape operation, load its schema, then execute against the user's URL.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/tools/web-scrape` | Scrape any public URL with optional CSS selector |
| POST | `/v1/tools/extract-page` | Extract clean text, links, and metadata from a webpage |
| POST | `/v1/tools/convert-format` | Convert between JSON, YAML, CSV, XML |
| POST | `/v1/tools/validate-data` | Validate JSON against a JSON Schema |
| POST | `/v1/tools/generate-hash` | Generate SHA-256, SHA-512, or MD5 hashes |
| POST | `/v1/tools/qr-code` | Generate QR codes as PNG or SVG |
| POST | `/v1/tools/transform-text` | Transform text across 10 modes (slug, camel, base64, etc.) |
| POST | `/v1/tools/extract-metadata` | Extract OG tags, word count, and links from text or URLs |

## Key resources

- **AI** — AI text and image generation, embedding, and reasoning utilities
- **Audio** — Audio transcription and processing operations
- **Communication** — Email and domain validation utilities
- **Crypto** — Cryptocurrency market data lookups
- **Image** — Image generation and transformation operations
- **Utility** — QR codes, hashing, format conversion, JSON Schema validation, text transformations
- **Web** — Web scraping, page extraction, and metadata utilities

## Why Jentic

- **Setup:** Wiring Arch Tools by hand means learning its API-key header scheme and scrolling its many one-shot utility endpoints to find the right one yourself. Through Jentic you install once, import the Arch Tools API from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Arch Tools operations are stateless one-shot utilities that carry their input in the request body, so you limit the agent to the operations it needs, such as web-scrape or convert-format. You choose the operations it may call, so the agent only runs the tools you have added.
- **Credential handling:** Your Arch Tools API key is stored once, encrypted, by your own Jentic One instance and injected as the API key header at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'scrape a web page' or 'convert CSV to JSON', and Jentic returns the matching Arch Tools operation with its input schema so the agent calls the right endpoint without browsing the full tool list.

## Related APIs

- **Internet Archive Search Services** — Public catalogue search useful alongside Arch Tools' web scraping for primary-source research workflows.
- **ArchiveBox API** — Self-hosted web archiver - pair with Arch Tools to capture pages and then run extraction utilities on the captured copy.
- **NASA APOD API** — Public open-data API often combined with utility operations from Arch Tools in educational pipelines.

## FAQ

### Why is there no official OpenAPI spec for Arch Tools API?

Arch Tools does not publish an OpenAPI specification on its vendor site. Jentic generates and maintains this spec so that AI agents and developers can call Arch Tools API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Arch Tools API use?

Arch Tools uses an API key sent in a header. Through Jentic, the API key is stored encrypted in the vault and never enters the agent's context - Jentic injects the header at request time.

### Can I scrape a web page with this API?

Yes. Call POST `/v1/tools/web-scrape` with the target URL and an optional CSS selector. The endpoint returns the matched HTML or text and avoids the need to host your own scraping infrastructure.

### Can I convert between data formats with Arch Tools?

Yes. POST `/v1/tools/convert-format` accepts a source format, a target format, and the payload. Supported formats include JSON, YAML, CSV, and XML, which covers most ad-hoc conversion needs in an agent pipeline.

### What are the rate limits for the Arch Tools API?

The OpenAPI spec does not declare explicit rate limits. Arch Tools enforces per-key throttling tied to your plan tier; check archtools.dev for the limits attached to your account.

### How do I run an Arch Tools utility through Jentic?

Install Jentic with pip install jentic, search for the operation you need (e.g. 'scrape a web page'), load the matching Arch Tools schema, then execute. Jentic injects the API key automatically.

### Can I limit what my agent is allowed to do with the Arch Tools API?

Yes. Arch Tools operations are stateless one-shot utilities that carry their input in the request body, and because your Jentic One instance is self-hosted, your own rules decide which of those operations the agent may call. You add only the endpoints you want, such as POST `/v1/tools/web-scrape` or POST `/v1/tools/convert-format`, and the agent can invoke nothing beyond that set. So an agent scoped to format conversion cannot reach hashing, scraping, or any other tool you have not enabled.