Drop real-time odds and player props into your React Native app with a plain fetch call. Normalized JSON, American odds, and one API key — no SDK to install.
The MoneyLine odds API is a plain REST/HTTPS API, so consuming it in React Native is just fetch — no native modules to link, no SDK to install, and no platform-specific build steps. Authenticate with the x-api-key header, hit a single endpoint, and render normalized odds directly in your components. The same REST contract works identically on iOS and Android, so there is nothing to special-case per platform.
Because every market is normalized to American odds under canonical event IDs, your mobile client stays thin. There is no per-sportsbook parsing and no reconciliation to do on-device: each event arrives in one consistent JSON shape, with moneyline, spread, total, and player-prop markets already converted to American prices. Responses are paginated, so even a broad multi-league screen pulls down a small payload that suits constrained mobile networks and keeps JSON parsing cheap.
Every event also carries a summary object with no-vig fair odds, the best available price, and the consensus average per outcome. That lets a mobile bet-comparison screen highlight the sharpest line without shipping a normalization layer inside the app bundle. Game lines and player props share the same canonical eventId, so a tab that lists games and a tab that drills into props can join on one field.
In production, keep the API key off the device. React Native bundles are inspectable, so the recommended pattern is to proxy odds requests through your own backend and let the server hold the key — the public env var shown in the examples below is fine for prototyping only. Either way, the client code is the same plain fetch; only the URL it calls changes.
Sign up and grab a key from the dashboard — no credit card for the free tier.
Pass the key as x-api-key and hit /v1/odds with the built-in fetch — no SDK or native module to install.
Map the normalized, paginated data into your components. In production, keep the key off-device by proxying the request through your backend.
No SDK or native modules — call the REST API with the built-in fetch from any component or hook.
Normalized, paginated responses keep mobile data usage and on-device JSON parsing minimal.
Prices arrive as American odds across every source, so you render them directly with no client-side conversion.
The same REST endpoints behave identically on iOS and Android — one code path, no platform branches.
Moneyline, spread, and total plus a deep set of player-prop markets across every major US league.
Odds and props share one eventId, so a games list and a prop detail screen join on a single field.
React Native — fetch odds in a component
Request
import { useEffect, useState } from 'react'
import { Text, View } from 'react-native'
const API_KEY = process.env.EXPO_PUBLIC_ML_API_KEY
export function NbaOdds() {
const [games, setGames] = useState([])
useEffect(() => {
fetch('https://mlapi.bet/v1/odds?league=nba&market=moneyline', {
headers: { 'x-api-key': API_KEY },
})
.then((r) => r.json())
.then((json) => setGames(json.data))
}, [])
return (
<View>
{games.map((g) => (
<Text key={g.eventId}>{g.eventId}</Text>
))}
</View>
)
}Response
{
"success": true,
"data": [
{
"eventId": "nba-ev-311286",
"leagueId": "nba",
"bookmakers": [
{
"bookmakerId": "draftkings",
"bookmakerName": "DraftKings",
"markets": [
{ "marketType": "moneyline", "outcomes": [
{ "name": "Boston Celtics", "price": -180 },
{ "name": "Los Angeles Lakers", "price": 155 }
] }
]
}
]
}
]
}| Concern | How it works |
|---|---|
| Just fetch | No SDK or native modules — use the built-in fetch |
| Thin payloads | Normalized, paginated responses keep mobile data and parsing minimal |
| API key | Keep the key off-device; proxy through your backend for production |
| Cross-platform | The same REST contract works on iOS and Android |
Render live odds screens and bet slips natively from one normalized feed.
Works in managed Expo and bare React Native alike — there are no native modules to link.
Show player props per event in a mobile-friendly layout, joined to games on the canonical eventId.
Surface the best available line per outcome using the per-event summary, no on-device math required.
Ship one fetch-based data layer that runs unchanged on both iOS and Android.
Call the REST API with the built-in fetch — pass your key as the x-api-key header to /v1/odds and render the normalized JSON in your components; no SDK or native module is required.
No. The API is plain REST over HTTPS, so the built-in fetch is all you need in React Native or Expo.
For production, proxy requests through your backend so the key is never shipped in the app bundle. Public env vars are fine only for prototyping.
Yes — there are no native modules to link, so it works in managed Expo and bare React Native alike.
Yes. It is the same REST contract over HTTPS, so one fetch-based data layer runs unchanged on both platforms.
NFL, NBA, MLB, NHL, NCAAF, and NCAAB, each with moneyline, spread, and total game lines plus player-prop markets.
Responses are normalized to one JSON shape and paginated, so even broad queries return thin payloads that are cheap to download and parse on-device.
Every event carries a canonical eventId shared by odds and props, so a games screen and a prop detail screen can join on that single field.
Free
$0/mo
1K credits/mo
Starter
$29/mo
150K credits/mo
Pro
$149/mo
1.5M credits/mo
Business
$299/mo
5M credits/mo
Enterprise
Custom
Unlimited credits/mo
Free tier to start, one API key, normalized responses across every league and sportsbook.