> Source: https://vitna.ai/docs/api/v1/log/feed
> Raw Markdown: https://vitna.ai/docs/api/v1/log/feed.md
> Corpus index: https://vitna.ai/llms.txt

# Feed

JSON Feed 1.1. The market log plus the triggers that fired and the decisions the
engine proposed, in something a reader, a bot or a chat channel can subscribe to.

```
GET /api/v1/feed.json
```

```bash
curl https://vitna.ai/api/v1/feed.json
```

Served as `application/feed+json; charset=utf-8`.

## Shape

Standard JSON Feed 1.1 (`version`, `title`, `home_page_url`, `feed_url`,
`description`, `language`, `items`), so any feed reader handles it unmodified.

Fifty items, newest first. A feed is the recent past, not the archive; use
[`/events`](events.md) to go further back.

## Three item kinds

Every item carries a `_vitna` extension object whose `kind` says which:

| `_vitna.kind` | Written when |
|---|---|
| `market_event` | A price moved, something launched, terms changed |
| `trigger_fired` | An armed watch matched the record |
| `proposal` | The engine produced a decision brief |

## `_vitna` on a market event

Carries `eventKind`, `origin`, `provider`, `sku` and `evidence`. Where the event
was detected rather than curated, the hashes of both archived documents are
appended to `content_text` as well, so a reader who wants to check a move does
not have to come back for them.

## Trigger items say what did not happen

A fired trigger's `content_text` states that the trigger is spent, that nothing
was routed and nothing was accepted, and that a fired trigger is a question put
to a person.

That sentence is in the payload rather than only in these docs, because a
notification implying the system took an action it did not take is the worst
thing this feed could carry.

## Proposal items carry their ruling

A proposal's status travels with it, so a reader returning to an item sees
whether a person has ruled on it: nobody has ruled yet, a person accepted it, or
a person refused it with the reason kept on the row. That third reading was
"it was overtaken without being accepted" until 2026-08-26, which is what the
status sounds like rather than what writes it. See
[the decision concept](../../../concepts/decision.md).

## Proposal items link to the decision

A proposal item carries a `url`, which is the decision's own page:

```
https://vitna.ai/decisions/{id}
```

Every proposal this feed carries belongs to an org whose feed is public, and
that is the same gate the page reads, so following one of these links never
lands on a 404.

## Market event items link to the event

A market event item's `url` is the event's own page, at its day and a slug of
its headline:

```
https://vitna.ai/log/{day}/{slug}
```

Its `external_url` is still the provider's own announcement. Until 2026-09-13
the `url` was the log anchored at the event's day, which landed on the first
event of that day rather than this one whenever two shared it.

The day and slug are the same ones the item's id is built from. Where two
events share a day and a headline, which the record allows for detected moves,
the one written first keeps the bare address and each later one takes `--2`,
`--3` in the order it was written, so an address already handed out never
moves.

## Item ids are stable

A market event's id is its day plus a slug of its headline, which is what
already identifies a curated event in the database through a partial unique
index. Trigger and proposal items use their record ids. Ids do not change, so a
reader will not see the same item twice.

## The same items as RSS

The same fifty items are published as RSS 2.0 at `https://vitna.ai/log/rss.xml`,
for a feed reader that looks for RSS rather than JSON Feed. It is a rendering of
this feed and never a second one: every `guid` is the id this feed gives the
same item, so a reader following both sees one item, and its `lastBuildDate` is
the newest item's own date rather than the time of the request. The log page and
every event page advertise both feeds as `<link rel="alternate">` in their head.

## The engine half can be absent

If the engine's record cannot be read, trigger and proposal items are omitted
and `_vitna.engineActivity` says so in words, rather than the feed appearing
quiet.

| `_vitna.source` | `_vitna.engineActivity` |
|---|---|
| `database` | `included` |
| `snapshot` | a sentence explaining it could not be read |

A feed reporting "no triggers have fired" while unable to look would be the
failure this record exists to prevent.

## Only published registers are here

The trigger and proposal items on this feed come only from organisations whose
register is published. An organisation whose register is private has its own
feed instead, at an address its owners get from the console:
[your organisation's feed](../engine/org-feed.md). That feed carries its triggers
and proposals and none of the market log, and this one is unchanged by it.

## Why a feed and not email

Email needs SMTP credentials, a monitored inbox and a deliverability problem.
A feed needs none of those, is public and cacheable, and every consumer already
knows how to read one. Email remains documented in `HOSTING.md` as an add-on
for whenever there is an inbox somebody reads.

## Caching

`public, max-age=60, stale-while-revalidate=3600`.
