Developers

Build with The Living Bread

Everything public about the Body of Christ on The Living Bread is open to read: gatherings, churches, ministries, needs, testimonies, answered prayers, Scripture from a stored text, and a tiny payload for devices. One API, open feeds and calendars, a Model Context Protocol server, embeddable buttons, and signed webhooks for verified churches. Free, no account needed to read, and never a private word.

Start in one minute

There is nothing to sign up for. The base address is https://discover.living-bread.org. Every endpoint answers GET with JSON, allows any origin, and carries an ETag. Try the device payload first, because it shows the whole spirit of the API in under a kilobyte: the verse the whole family receives today, read from the stored King James Version, how many people prayed through The Living Bread in the last hour, and the next public gathering.

# upcoming public gatherings in Seattle, as plain JSON
curl -s 'https://discover.living-bread.org/api/gatherings?city=seattle&days=7'

# the same as JSON-LD (schema.org Event)
curl -s -H 'Accept: application/ld+json' 'https://discover.living-bread.org/api/gatherings?city=seattle'

# conditional request: 304 when nothing changed
curl -s -i -H 'If-None-Match: "<etag from the last response>"' 'https://discover.living-bread.org/api/needs'

# the device payload, as plain text
curl -s 'https://discover.living-bread.org/api/now.txt'

# a passage, read from the stored King James Version
curl -s 'https://discover.living-bread.org/api/scripture/john-3-16'

The Kingdom Protocol

Every object the API returns is one of the thirteen objects of the Kingdom Protocol: Gathering, Church, Ministry, Community, Need, ServiceOpportunity, Offering, Person, Testimony, Prayer, ScriptureReference, Place and Response. Each has a JSON Schema at https://living-bread.org/protocol/v0.1/<object>.schema.json, a stable lb: identifier, and a schema.org mapping. Read the protocol page before you store anything: the consent rules there are part of the contract.

API reference

EndpointWhat it returns
GET /apiIndex of the Knowledge API: endpoints, coverage, license
GET /api/protocolProtocol card: kinds, schemas, contexts, endpoints
GET /api/gatherings?city=&country=&church=&kind=&days=&limit=Upcoming public gatherings
GET /api/gathering/{uuid}One gathering
GET /api/gathering-citiesCities with upcoming public gatherings, and their slugs
GET /api/church/{uuid}A church on the app
GET /api/church/{country}/{slug}A church in the open directory
GET /api/nearby?country=&lat=&lon=&limit=Directory churches nearest a point
GET /api/ministriesMinistries
GET /api/ministry/{slug}One ministry
GET /api/communities?city=Discoverable prayer, discipleship and mission groups
GET /api/community/{uuid}One community
GET /api/needs?country=&city=&people=1Verified open needs
GET /api/need/{uuid}One need
GET /api/service-opportunities?country=&city=Needs that ask for people
GET /api/testimonies?limit=&before=Public testimonies, newest first
GET /api/testimony/{uuid}One testimony
GET /api/prayer/{uuid}One prayer with a public door (by id only)
GET /api/answeredAnswered prayers
GET /api/person/{handle}A public profile
GET /api/placesPrayer regions (geohash 3, three or more people)
GET /api/praying-now?hours=People who prayed in a window, by country
GET /api/scripture/{ref}A passage from the stored King James Version
GET /api/verify?quote=&reference=&translations=Is this quotation really Scripture? verbatim, close with a word diff, or not found in any held translation; SHA-256 per verse (GET or POST)
GET /ask?query=&streaming=falseNLWeb: the grounded engine as schema.org JSON-LD results (Microsoft NLWeb REST API, version 0.55)
GET /api/response/{kind}/{uuid}Counts of how the Body answered an object
GET /api/resolve/{urn}Any lb: URN to its object
GET /api/nowThe device payload (JSON); /api/now.txt or ?format=text for plain text; ?city=
GET /api/now/streamServer-Sent Events: one now event a minute, closes after five minutes
GET /openapi.jsonOpenAPI 3.1 contract

Add ?format=jsonld, or send Accept: application/ld+json, to any object or list endpoint and the answer is schema.org JSON-LD: a gathering is an Event with its status and attendance mode, a church a Church, a ministry an NGO, a community an Organization, a public profile a Person, a testimony or a prayer a CreativeWork, a need a Demand, a passage a Quotation of the King James Version, a prayer region a Place, and a set of counts an InteractionCounter. Each JSON-LD object carries its lb: URN as identifier and its protocol schema as additionalType.

The machine contract is OpenAPI 3.1 at https://discover.living-bread.org/openapi.json, so code generators and assistants can discover every endpoint without reading this page.

Feeds and calendars

FeedWhat it carries
/feedsIndex of every feed (JSON)
/feeds/daily-bread.rss | .atom | .jsonThe Daily Bread, the verse the whole family receives each morning
/feeds/testimonies.rss | .atom | .jsonPublic testimonies
/feeds/answered.rss | .atom | .jsonAnswered prayers
/feeds/gatherings/{city-slug}.rss | .atom | .json | .icsUpcoming public gatherings in a city
/feeds/prayer-gatherings.rss | .atom | .json | .ics?city=Prayer gatherings, everywhere or in one city
/feeds/church/{uuid}.icsOne church's public gatherings as a calendar

RSS 2.0, Atom 1.0 and JSON Feed 1.1 carry the same items, so use whichever your reader, aggregator or automation prefers. The ICS calendars are standard iCalendar: add the address to Apple Calendar, Google Calendar or Outlook as a subscription and a church's public gatherings appear on a phone and stay current. A cancelled gathering stays in the calendar marked cancelled, so nobody drives to a locked door.

Use the city slug from /api/gathering-cities, for example seattle, los-angeles or san-diego. A city with no upcoming public gathering returns an empty feed, honestly, rather than a neighbouring city's.

For devices: /api/now

Smart displays, e-ink frames, watches, voice assistants, car dashboards and small boards on a church wall need very little, very reliably. /api/now returns under a kilobyte: today's Daily Bread reference and its words from the stored King James Version, the number of people who prayed through The Living Bread in the last hour, and the next public gathering, optionally in your city with ?city=. Ask for /api/now.txt, or add ?format=text, and it is plain text a voice assistant can read aloud as it stands.

It is cached for sixty seconds, so poll it once a minute at most. If you would rather be told, open /api/now/stream with EventSource: the server sends one now event a minute and closes the stream after five minutes, and EventSource reconnects on its own. A device that cannot hold a connection open should simply poll.

Examples

JavaScript

// today's bread and the next gathering, for a display or a widget
const now = await fetch('https://discover.living-bread.org/api/now?city=seattle').then(r => r.json());
console.log(now);

// live: one event a minute; EventSource reconnects by itself
const es = new EventSource('https://discover.living-bread.org/api/now/stream');
es.addEventListener('now', (e) => render(JSON.parse(e.data)));

// resolve any Kingdom Protocol identifier
const obj = await fetch('https://discover.living-bread.org/api/resolve/' + encodeURIComponent('lb:ministry:hope-for-a-good-life'))
  .then(r => r.json());

Python

import requests

BASE = 'https://discover.living-bread.org'
needs = requests.get(f'{BASE}/api/service-opportunities', params={'country': 'Rwanda'}, timeout=20).json()
for n in needs.get('items', needs if isinstance(needs, list) else []):
    print(n['title'], n.get('city'), n['ministry']['name'])

# verify a webhook delivery (once webhooks open)
import hmac, hashlib
def verified(raw_body: bytes, header: str, secret: str) -> bool:
    parts = dict(p.split('=', 1) for p in header.split(','))
    mac = hmac.new(secret.encode(), (parts['t'] + '.').encode() + raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(mac, parts['v1'])

Model Context Protocol

Assistants that speak MCP connect to https://mcp.living-bread.org/mcp (Streamable HTTP, no authentication for the public tools; older clients may use https://mcp.living-bread.org/sse). The server reads Scripture from a stored text, names real churches and gatherings, and hands people real doors. It now also carries three tools built on these same public doors: gatherings_tonight, where_can_i_serve_publicly, and kingdom_protocol_lookup, which resolves any lb: identifier. Every tool declares whether it is read only and whether it reaches beyond the house's own data. The discovery file is https://living-bread.org/.well-known/mcp.json.

How an assistant discovers these capabilities and offers them to a person, voluntarily and with consent, is specified in the Living Bread Intelligence Invitation Protocol, with its manifest at https://living-bread.org/.well-known/lbiip.json.

Verify a quotation of Scripture

Language models misremember verses, join two into one, and attribute proverbs of men to the Bible. Before quoting, send the exact words to https://discover.living-bread.org/api/verify?quote=<words>&reference=<optional> (or POST the same as JSON). The answer is a verdict: verbatim, close_but_differs, resembles, or not_found. With it come the closest real verse or verses with reference, translation and the stored words, a SHA-256 of each verse as stored, a word by word diff of what differs, whether the claimed reference holds those words, and, when nothing held is close, the plain sentence that the wording is not found in any held translation.

The King James Version is checked by default. Add translations=es, de, fr and the others listed in the answer's translations_held, up to three at a time, each with the license its source carries. A faithful quotation from a translation that is not held will show as differing; the answer says so, because a difference from these texts is not proof of an error. The same check is the MCP tool verify_scripture_quote, and both run one shared implementation.

curl -s 'https://discover.living-bread.org/api/verify?quote=God%20helps%20those%20who%20help%20themselves'

curl -s -X POST 'https://discover.living-bread.org/api/verify' -H 'Content-Type: application/json' \
  -d '{"quote":"<the words>","reference":"John 3:16","translations":["KJV","es"]}'

NLWeb and Agent2Agent

https://discover.living-bread.org/ask answers Microsoft's NLWeb protocol (the REST API of github.com/nlweb-ai/NLWeb, API version 0.55): query, site, prev, decontextualized_query, streaming, query_id and mode, by GET or POST, including the structured body with query.text, prefer and meta. Each result carries url, name, site, score, a factual description and a schema.org JSON-LD schema_object: a Quotation of the stored King James text, a Church directory collection page, an Event for a public gathering, a Person or Place of the knowledge graph. Streaming is the protocol's default; add streaming=false for one JSON object. mode=generate is answered with the grounded list and a factual summary, because nothing here composes prose with a language model.

Agents that speak Agent2Agent find The Living Bread at https://mcp.living-bread.org/.well-known/agent-card.json (A2A 1.0): four skills, Scripture with evidence, verification, churches and gatherings, and real people who will pray, over one JSON-RPC interface. The card is mirrored at living-bread.org/.well-known/agent-card.json.

curl -s 'https://discover.living-bread.org/ask?query=churches%20in%20Kenya&streaming=false'

curl -s https://mcp.living-bread.org/.well-known/agent-card.json

Embeds: Pray for Me, and Continue in Living Bread

A church or ministry can put a Pray for Me button on its own website. A visitor types a first name, or chooses to stay anonymous, writes what they would like prayer for, and may leave an email to hear later how many people prayed. The request goes to that church's own people inside the prayer network The Living Bread already has. Site keys are created by a leader of the church or ministry in the app, on the church dashboard, under Pray for Me on your website.

<script src="https://living-bread.org/embed.js" data-widget="pray-for-me" data-site="lbs_your_site_key" async></script>

Where scripts are not allowed, the same form works in an iframe:

<iframe src="https://discover.living-bread.org/embed/pray-for-me?site=lbs_your_site_key" title="Ask for prayer" style="border:0;width:100%;max-width:460px;height:520px" loading="lazy"></iframe>

Requests are held for the leaders to read first, unless the church or ministry is verified and chose to publish without review. Each site may receive twenty requests an hour and a hundred a day by default, one sender three an hour, and a hidden field turns away automated submissions. The email to the person who asked is sent only once the mail service is switched on, and every one carries a link that withdraws the request.

The Continue in Living Bread buttons turn Christian content into a Christian act: Pray about this, Talk to someone, Find a community, Join this gathering, Serve here, and Carry this Scripture.

<script src="https://living-bread.org/embed.js" data-widget="continue" async></script>

The full widget gallery, with plain HTML versions for sites that strip scripts, is at /widgets.

Webhooks (built, not yet open)

A verified church or ministry will be able to receive signed webhooks about its own things: prayer.created when a request from its Pray for Me button is published, prayer.responded when more people have prayed for one, event.created when it publishes a public gathering, need.created when one of its needs is verified and opened, and need.fulfilled when a need is met. Webhooks are built and tested in the database and are not yet open; the subscribe call answers plainly that they are not open until delivery has been proven end to end.

API keys are minted by a leader in the app and shown once. Subscriptions are managed with the public anon key through https://eiekmrbmscorzjogpbzf.supabase.co/rest/v1/rpc/webhook_subscribe, webhook_unsubscribe and webhook_subscriptions_list.

curl -s 'https://eiekmrbmscorzjogpbzf.supabase.co/rest/v1/rpc/webhook_subscribe' \
  -H 'apikey: <the public anon key>' -H 'Content-Type: application/json' \
  -d '{"p_api_key":"lbk_...","p_url":"https://your.server/hooks/living-bread",
       "p_events":["prayer.created","prayer.responded","event.created"]}'

Each delivery is a POST with a JSON body and three headers: X-Living-Bread-Event, X-Living-Bread-Delivery and X-Living-Bread-Signature in the form t=,v1=, where v1 is the HMAC SHA-256 of the timestamp, a dot, and the raw body, keyed with your subscription's whsec_ secret. Verify it, and reject a timestamp older than five minutes. A delivery that does not receive a 2xx is retried after one, two, four, eight minutes and onward, and is set aside as a dead letter after eight failures.

Rate limits, caching and status codes

Privacy rules you inherit

By reading these doors you take on their rules. Do not combine objects to locate a person. Do not store a prayer or a testimony longer than you need to show it, and remove it when its door answers 404. Do not train a model on words written by people, do not use them to advertise or to raise money, and never present a prayer as a signal about someone. Public data only means more than what is technically reachable; it means what the person chose to share, used for the reason they shared it.

Choosing a door

If you are building a page for people, use the feeds and the ICS calendars: they are cached at the edge, they update themselves, and every calendar app and reader already understands them. If you are building for a device, use /api/now and nothing else; it was made small so that a battery powered frame can wake, read one short answer, and sleep again. If you are building for an assistant, prefer the MCP server, because its tools already carry the safety rules, such as giving a crisis line before anything else when someone is in danger. If you are building a dataset or a directory, use the object endpoints with conditional requests, and resolve identifiers rather than scraping pages.

Design principles

License and attribution

Directory data is CC BY 4.0: attribute The Living Bread with a link to living-bread.org. Scripture is the King James Version, in the public domain. People's words remain theirs; quote them with attribution. If your product helps someone find a church, a gathering or a person who will pray with them, point them past your product and past ours, to the people and to Christ.

The Living Bread, a nonprofit in Seattle, Washington (EIN 33-1848176). About · Our programs · Organization verification · Editorial policy · Contact