BibleHub APIbiblehub.com ↗
Access Strong's Hebrew and Greek lexicon entries, interlinear verse analysis, and morphology data from BibleHub via a structured JSON API.
What is the BibleHub API?
The BibleHub API exposes 4 endpoints for retrieving biblical language data, including full Hebrew and Greek lexicon entries keyed by Strong's number, word-by-word interlinear analysis for any Old or New Testament verse, and keyword-based lexicon search. The get_interlinear_verse endpoint returns a words array with individual Strong's numbers, transliterations, English glosses, and morphology codes for every word in a specified chapter, verse, and book.
curl -X GET 'https://api.parse.bot/scraper/0a2a8344-f84d-41c5-9ec5-793cc6306540/get_hebrew_lexicon?strongs_number=430' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace biblehub-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""BibleHub Biblical Studies API — bounded, re-runnable walkthrough."""
from parse_apis.biblehub_biblical_studies_api import BibleHub, Language, EntryNotFound
client = BibleHub()
# Look up a Hebrew word by Strong's number — direct typed access.
hebrew = client.hebrewentries.get(strongs_number="430")
print(hebrew.original_word, hebrew.transliteration, hebrew.part_of_speech)
# Look up a Greek word — demonstrates the parallel Greek collection.
greek = client.greekentries.get(strongs_number="25")
print(greek.original_word, greek.transliteration, greek.lexical_summary)
print(greek.definitions.nas)
# Interlinear verse analysis — each word carries morphology and Strong's link.
verse = client.interlinearverses.lookup(book="Genesis", chapter=1, verse=1)
print(verse.language, f"{verse.book} {verse.chapter}:{verse.verse}")
for w in verse.words[:3]:
print(w.word, w.transliteration, w.english, w.morphology)
# Search the lexicon with the Language enum — limit caps total items fetched.
for result in client.searchresults.search(query="love", language=Language.HEBREW, limit=5):
print(result.strongs_number, result.text)
# Typed error handling: catch EntryNotFound for an invalid Strong's number.
try:
client.hebrewentries.get(strongs_number="99999")
except EntryNotFound as exc:
print(f"Not found: {exc.strongs_number}")
print("exercised: hebrewentries.get / greekentries.get / interlinearverses.lookup / searchresults.search")
Retrieve detailed Hebrew lexicon data for a given Strong's number. Returns the original Hebrew word, morphology, definitions from Strong's Exhaustive Concordance and NAS, Brown-Driver-Briggs entry, word origin, and concordance usage examples. Numbers range from 1 to approximately 8674.
| Param | Type | Description |
|---|---|---|
| strongs_numberrequired | string | Strong's Hebrew number (e.g., 1, 430, 2617) |
{
"type": "object",
"fields": {
"language": "string, always 'hebrew'",
"concordance": "array of objects with 'reference' and 'text' keys",
"definitions": "object with optional keys 'nas' and 'strongs_exhaustive' containing definition text",
"word_origin": "string, etymology and origin information",
"original_word": "string, Hebrew word in original script",
"pronunciation": "string",
"part_of_speech": "string, grammatical category",
"strongs_number": "string, the requested Strong's number",
"lexical_summary": "string, brief word summary",
"transliteration": "string, romanized form",
"phonetic_spelling": "string",
"brown_driver_briggs": "string, BDB lexicon entry text"
},
"sample": {
"data": {
"language": "hebrew",
"concordance": [],
"definitions": {
"nas": "Word Origin pl. of eloah Definition God, god",
"strongs_exhaustive": "angels, exceeding, God, very great, mighty"
},
"word_origin": "[plural of H433]",
"original_word": "אֱלהִים",
"pronunciation": "eh-lo-HEEM",
"part_of_speech": "Noun Masculine",
"strongs_number": "430",
"lexical_summary": "elohim: God, gods, divine beings, judges",
"transliteration": "elohiym",
"phonetic_spelling": "(el-o-heem')",
"brown_driver_briggs": "noun masculine plural"
},
"status": "success"
}
}About the BibleHub API
Lexicon Lookup
get_hebrew_lexicon and get_greek_lexicon each accept a Strong's number and return a consistent set of fields: original_word in the source script, transliteration, pronunciation, part_of_speech, word_origin, lexical_summary, and a definitions object that may include both nas (New American Standard) and strongs_exhaustive definition text. Hebrew entries include data drawn from the Brown-Driver-Briggs lexicon; Greek entries include Thayer's Greek Lexicon material. Both endpoints also return a concordance array of {reference, text} pairs showing real verse occurrences of the word.
Interlinear Verse Analysis
get_interlinear_verse takes book, chapter, and verse as inputs and returns a words array where each element carries strongs_number, word (original script), transliteration, english, and morphology. The language field in the response is 'hebrew' for Old Testament books and 'greek' for New Testament books, so a single endpoint covers the full canon. Books with spaces in their names use underscore notation in the book parameter (e.g., 1_Samuel).
Lexicon Search
search_lexicon accepts a query string and an optional language filter ('hebrew' or 'greek'). It returns a results array of objects with strongs_number, text, and summary, making it useful for discovering Strong's numbers when you only know an English gloss or approximate transliteration. Omitting language returns matches across both language corpora.
The BibleHub API is a managed, monitored endpoint for biblehub.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when biblehub.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official biblehub.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a Bible study tool that displays original-language word definitions inline alongside English translations using
get_interlinear_verse. - Populate a flashcard app with Hebrew or Greek vocabulary by pulling
original_word,transliteration, anddefinitionsfrom the lexicon endpoints. - Cross-reference how a specific Strong's word (e.g., H2617, 'hesed') is used across the Old Testament via the
concordancearray. - Generate morphology breakdowns for seminary students by iterating
get_interlinear_verseacross a passage and groupingmorphologycodes. - Resolve an English keyword like 'grace' to its underlying Greek Strong's entries using
search_lexiconbefore fetching full definitions. - Build a word-frequency tool by collecting
strongs_numbervalues across multiple interlinear verses and aggregating counts. - Power a language-learning interface showing
part_of_speech,word_origin, andlexical_summaryfor any Strong's entry the user looks up.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does BibleHub have an official developer API?+
What does the `words` array in `get_interlinear_verse` actually contain?+
words includes strongs_number, word (the token in Hebrew or Greek script), transliteration, english (the English gloss for that token), and morphology (a coded string indicating grammatical properties like tense, person, case, or stem). The top-level language field tells you whether the verse is analyzed as Hebrew or Greek.Are both NAS and Strong's Exhaustive definitions always present in lexicon responses?+
definitions object has optional keys: nas and strongs_exhaustive are included when that source material is available for the given Strong's entry. Some entries may have only one or neither key populated. The lexical_summary field provides a brief definition that is consistently present.Does the API support looking up verses by passage range, such as an entire chapter at once?+
get_interlinear_verse accepts a single book, chapter, and verse combination and returns one verse at a time. To cover a full chapter, you would need to call the endpoint once per verse. You can fork this API on Parse and revise it to add a chapter-range endpoint that iterates verses and returns a collected response.Does the API expose audio pronunciation files or parsing tables beyond the morphology code string?+
pronunciation string (text representation), not an audio file. Morphology is returned as a coded string in the morphology field of interlinear word objects; the API does not expand those codes into human-readable parsing tables. You can fork the API on Parse and revise it to decode morphology codes into structured labels.