canonical: https://jentic.com/apis/rentry.co/rentry

# Rentry

Jentic publishes the only available OpenAPI specification for Rentry, keeping it validated and agent-ready. The Rentry API publishes markdown text as a shareable web page at a custom or auto-generated rentry.co URL, then reads, edits and deletes those entries afterwards. Requests are form-encoded and go to the /api endpoints on rentry.co, which are CSRF-exempt, and each entry is guarded by its own edit code rather than an account-wide key.

## For AI agents

Create, edit, read, fetch and delete Rentry markdown entries programmatically. Covers 5 operations; editing, fetching and deleting an entry each require that entry's own edit code.

## Scope

Does not list or search entries, does not manage users or accounts, and does not touch any resource other than entries: the bound spec is 5 POST operations that each act on one entry, addressed by the url it was published at, so an agent must already know that url to read, edit or delete it.

## Capabilities

- Create a new entry
- Edit an existing entry
- Get raw markdown text of an entry
- Fetch entry details including metadata
- Delete an entry

## Use cases

### Developer Tools Operations

Publish and maintain markdown pages on Rentry programmatically: create an entry from text plus optional metadata, update its text or metadata later, read back its raw markdown, and delete it when it is no longer needed.

Example prompt: Call POST /new to create a new entry

### Automated Entries Management

Automate entry maintenance by combining multiple Rentry endpoints. Agents can edit an existing entry and then read back its raw markdown text in a single workflow.

Example prompt: Call POST `/edit/{url}` to edit an existing entry, then verify the result

### AI Agent Integration via Jentic

AI agents discover and call Rentry operations through Jentic without hard-coding its endpoints. An agent searches for the operation it needs by intent, receives the matching input schema, and executes the call while your own self-hosted Jentic One instance injects the stored edit code at execution time. This removes the need to read the reference docs or paste entry codes into the agent by hand.

Example prompt: Search Jentic for 'create a new entry', load the operation schema, and execute with the credential injected by your Jentic One instance

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/new` | Create a new entry |
| POST | `/edit/{url}` | Edit an existing entry |
| POST | `/raw/{url}` | Get raw markdown text of an entry |
| POST | `/fetch/{url}` | Fetch entry details including metadata |
| POST | `/delete/{url}` | Delete an entry |

## Key resources

- **Entries** — Create, edit, fetch and delete entries

## 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:** 60 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 90 / 100
  - Developer Experience & Jentic Compatibility: 61 / 100
  - AI-Readiness & Agent Experience: 45 / 100
  - Agent Usability: 94 / 100
  - Security: 50 / 100
  - AI Discoverability: 50 / 100
- **View full report:** https://jentic.com/apis/rentry.co/rentry/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 Rentry by hand means tracking a separate edit code for every entry you create, form-encoding each request to its /api endpoints, remembering that every response arrives as HTTP 200 with the real status inside the JSON body, and mapping the new, edit, raw, fetch and delete endpoints yourself. Through Jentic you install once, import Rentry from the Jentic API Directory, store the code once, and your agent calls it.
- **Permission scoping:** Rentry puts the entry url in the URL path (`/edit/{url}`, `/fetch/{url}`), so a rule can pin your agent to fetching and reading the raw content of one entry. You choose the operations it may call, so editing or deleting an entry is not included unless you add them.
- **Credential handling:** Your Rentry credential is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a new entry' or 'fetch an entry', and Jentic returns the matching Rentry operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **GitHub v3 REST API (GHEC)** — GitHub Enterprise Cloud's v3 REST API, 1176 endpoints covering repositories, issues, pull requests, Actions and enterprise admin, where Rentry covers 5 operations on standalone markdown pages.
- **GitLab REST API** — GitLab's REST API, 358 endpoints across projects, merge requests, CI/CD pipelines and container registries, where Rentry covers 5 operations on standalone markdown pages.

## FAQ

### What authentication does the Rentry API use?

Rentry's /api endpoints are CSRF-exempt, so no CSRF token, cookie or Referer header is needed. Access is granted per entry instead: editing, fetching and deleting an entry require that entry's `edit_code` in the form body, and reading an entry over `/api/raw` needs an access code issued by Rentry admins and sent in the rentry-auth header. Through Jentic, those codes are stored encrypted by your own Jentic One instance and injected at execution time, so raw secrets never enter the agent context.

### Can I create a new entry with the Rentry API?

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

### What are the rate limits for the Rentry API?

Rentry's own documentation publishes a specific limit: anonymous entry creation is rate-limited per IP, roughly 10 per minute on rentry.co, and is configurable on self-hosted Rentry instances. Responses always come back as HTTP 200, so read the `status` value inside the JSON body: a `429` there means slow down and retry later.

### How do I create a new entry through Jentic?

Install Jentic One, the self-hosted execution layer, then import Rentry from the Jentic API Directory and store its edit code once. Your agent searches for 'create a new entry', Jentic returns the matching Rentry operation with its input schema, and the call executes with the credential injected by your own instance.

### How many endpoints does the Rentry API have?

Rentry exposes 5 endpoints, and all five are POST operations on a single entry: POST /new creates one, POST `/edit/{url}` updates its text or metadata, POST `/raw/{url}` returns its markdown source, POST `/fetch/{url}` returns its details and metadata, and POST `/delete/{url}` removes it. Rentry documents no other resource.

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

Yes. Because you self-host Jentic One, your own rules decide which Rentry operations and credentials the agent may use. Since Rentry puts the entry in the URL path (`/fetch/{url}` and `/raw/{url}`), you can pin the agent to fetching an entry and reading its raw markdown for a single entry, while leaving out POST /new, POST `/edit/{url}`, and POST `/delete/{url}` unless you explicitly add them. The agent can only call the operations you have allowed.

### Is there a Rentry MCP server?

You do not need an MCP server to give your agent Rentry. Jentic connects it directly from the Jentic API Directory: import Rentry, store its edit code once, and your agent calls the operations you allow, with the code injected by your own Jentic One instance at execution time.

### Why is there no official OpenAPI spec for Rentry?

Rentry documents its API as prose in the official radude/rentry README and ships an official Python client, but it publishes no machine-readable OpenAPI document. Probes on 2026-08-13 of rentry.co/openapi.json, /openapi.yaml and /swagger.json all returned the site's own 404 page, and the official repository's full 24-file tree contains no specification. Jentic wrote the specification this page describes and keeps it aligned with the vendor's README and client source.
