canonical: https://jentic.com/apis/restful4up.local/restful4up-local

# RESTful4Up

RESTful API 4 Unipacker. The API exposes 4 endpoints.

## For AI agents

Programmatically unpack, emulationoutput. Covers 4 operations.

## Scope

Does not handle payments, communications, or crm - use for developer tools only.

## Capabilities

- unpack
- emulationOutput
- generatePartialYaraRule
- applyYaraRules
- Monitor RESTful4Up operational status and events

## Use cases

### Developer Tools Operations

Use the RESTful4Up to perform developer tools operations programmatically. The API provides 4 endpoints covering core functionality including unpack, emulationoutput, generatepartialyararule.

Example prompt: Call POST /unpack to unpack

### Automated Apply Yara Rules Management

Automate apply yara rules operations by combining multiple RESTful4Up endpoints. Agents can emulationoutput and then generatepartialyararule in a single workflow.

Example prompt: Call POST /emulation-output to emulationoutput, then verify the result

### AI Agent Integration via Jentic

AI agents discover and call RESTful4Up endpoints through Jentic without managing credentials directly. An agent searches for the required operation by intent, receives the matching endpoint schema, and executes the call with Jentic-managed authentication. This eliminates the need to read API documentation or handle none tokens manually.

Example prompt: Search Jentic for 'unpack', load the operation schema, and execute with Jentic-managed credentials

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/unpack` | unpack |
| POST | `/emulation-output` | emulationOutput |
| POST | `/generate-partial-yara-rules` | generatePartialYaraRule |
| POST | `/apply-yara-rules` | applyYaraRules |

## Key resources

- **Apply Yara Rules** — Operations for apply yara rules
- **Clean** — Operations for clean
- **Emulation Output** — Operations for emulation output
- **Generate Partial Yara Rules** — Operations for generate partial yara rules
- **Unpack** — Operations for unpack

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 55 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 100 / 100
  - Developer Experience & Jentic Compatibility: 66 / 100
  - AI-Readiness & Agent Experience: 28 / 100
  - Agent Usability: 94 / 100
  - Security: 100 / 100
  - AI Discoverability: 50 / 100
- **View full report:** https://jentic.com/apis/restful4up.local/restful4up-local/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring RESTful4Up by hand means standing up its unauthenticated /v1 endpoints and orchestrating unpack, emulation, and YARA-rule calls yourself. Through Jentic you install once, import RESTful4Up from the API Directory, and your agent calls it without extra wiring.
- **Permission scoping:** RESTful4Up takes its inputs in the request body rather than a resource id in the URL path. Limit the agent to the operations it needs, such as unpacking a sample or applying YARA rules, so it works within the operations you approve.
- **Credential handling:** RESTful4Up runs without a credential, and any configuration your own Jentic One instance holds is stored encrypted and injected at execution time. Nothing sensitive enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'unpack a sample' or 'apply YARA rules', and Jentic returns the matching RESTful4Up operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Github** — Alternative developer tools API
- **Gitlab** — Alternative developer tools API

## FAQ

### What authentication does the RESTful4Up use?

The RESTful4Up uses no authentication. Through Jentic, these credentials are stored encrypted in your Jentic One instance and injected at execution time, so raw secrets never enter the agent context.

### Can I unpack with the RESTful4Up?

Yes. Use the POST /unpack endpoint. The API returns structured JSON responses that agents can parse and act on directly.

### What are the rate limits for the RESTful4Up?

Rate limits are not specified in the OpenAPI spec. Check the vendor documentation for current limits. Through Jentic, rate limiting is handled automatically with retry logic built into the execution layer.

### How do I unpack through Jentic?

Install the Jentic SDK with pip install jentic, authenticate through Jentic One, the self-hosted execution layer, then search for 'unpack'. Jentic returns the matching RESTful4Up operation with its input schema. Load the schema and execute the call - credentials are injected automatically.

### How many endpoints does the RESTful4Up have?

The RESTful4Up exposes 4 endpoints covering apply yara rules, clean, emulation output operations.

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

Yes. Jentic One is self-hosted, so you run it and your own rules decide which RESTful4Up operations and configuration the agent can use. RESTful4Up takes its inputs in the request body rather than a resource id in the path, so you scope access at the operation level: you can allow only the calls you approve, such as POST /unpack or POST /apply-yara-rules, while withholding POST /emulation-output or POST /generate-partial-yara-rules. The agent can invoke only the operations you have granted.