1weuuy API1weuuy.life ↗
Access Lucky Jet VIP crash history and live game state from 1win via 2 endpoints. Returns coefficients, provably fair hashes, round IDs, and current game phase.
What is the 1weuuy API?
This API covers the Lucky Jet VIP crash game on 1win through 2 endpoints: get_crash_history and get_game_state. get_crash_history returns the 20 most recent completed rounds with final crash coefficients, SHA-512 hashes, and salts for provably fair verification. get_game_state delivers the current round's phase, active bet count, live multiplier, and server timestamp — giving you everything needed to track game state in real time.
curl -X GET 'https://api.parse.bot/scraper/897714fb-6dbf-4354-ae5a-330006601741/get_crash_history?limit=10' \ -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 1weuuy-life-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.
"""Walkthrough: Lucky Jet VIP SDK — bounded, re-runnable; every call capped."""
from parse_apis.Lucky_Jet_VIP_API import LuckyJet, ParseError
client = LuckyJet()
# Fetch recent crash history for coefficient analysis
for round in client.rounds.list(limit=3):
print(round.id, round.coefficient, round.hash[:16])
# Get current live game state
try:
state = client.game_states.current()
print(state.current_state, state.current_coefficient, state.bet_count)
except ParseError as e:
print(f"error: {e.code}")
print("exercised: rounds.list, game_states.current")
Returns up to 20 most recent completed crash rounds with their final coefficients and provably fair verification data (SHA-512 hash + salt). Each round's coefficient is the multiplier at which the jet crashed. Results are ordered from most recent to oldest. The upstream source provides a maximum of 20 rounds per request.
| Param | Type | Description |
|---|---|---|
| limit | integer | Maximum number of rounds to return (1-20). The upstream source provides at most 20 rounds. |
{
"type": "object",
"fields": {
"count": "number of rounds returned",
"rounds": "array of crash round objects with id, coefficient, hash, and salt"
},
"sample": {
"data": {
"count": 20,
"rounds": [
{
"id": "f7bc38fb-0af8-4ee9-ad04-a82f5159fbd1",
"hash": "REDACTED_SECRET",
"salt": "REDACTED_SECRET",
"coefficient": 2.13
},
{
"id": "708b29fe-db25-407f-b61f-f18bf1773f33",
"hash": "REDACTED_SECRET",
"salt": "REDACTED_SECRET",
"coefficient": 1.45
}
]
},
"status": "success"
}
}About the 1weuuy API
Crash History
get_crash_history returns an array of up to 20 completed Lucky Jet VIP rounds ordered from most recent to oldest. Each object in the rounds array includes a round id, the coefficient at which the jet crashed (the final multiplier), a SHA-512 hash, and a salt. The count field confirms how many rounds are in the response. These fields let you verify each round independently using the provably fair scheme and build a local record of coefficient distributions.
Live Game State
get_game_state reflects the current round in real time. The current_state field cycles through three phases: betting (players can place bets), flying (the multiplier is climbing), and ending (the round has resolved). During the flying phase, current_coefficient updates to the live multiplier; after a crash, it holds the final value. bet_count shows how many active bets are in the round. state_changed_at is the ISO timestamp of the last phase transition, and current_time is the server's current ISO timestamp. The provably_fair object contains the algorithm name and hash for the active round.
Verification and Data Freshness
Both endpoints return provably fair data — hashes and salts — that correspond to the 1win platform's verification scheme for Lucky Jet VIP. History is limited to the 20 most recent rounds per call; there is no pagination or date-range filtering. For ongoing tracking, poll get_game_state to detect phase transitions and call get_crash_history at the end of each round to capture new coefficients.
The 1weuuy API is a managed, monitored endpoint for 1weuuy.life — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when 1weuuy.life 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 1weuuy.life 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?+
- Log crash coefficients from
get_crash_historyto build a local dataset of Lucky Jet VIP round outcomes. - Verify round fairness independently by matching the
hashandsaltfields against the SHA-512 provably fair scheme. - Detect the start of the betting window by polling
get_game_statefor acurrent_statevalue ofbetting. - Track the live multiplier during the
flyingphase usingcurrent_coefficientfromget_game_state. - Monitor
bet_countacross rounds to observe participation volume over time. - Calculate coefficient frequency distributions across the 20-round history window to identify streaks or gaps.
- Timestamp round phase transitions using
state_changed_atandcurrent_timefor latency-sensitive applications.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does 1win provide an official developer API for Lucky Jet VIP game data?+
What does `get_crash_history` actually return, and can I request more than 20 rounds?+
id, the final coefficient, a SHA-512 hash, and a salt. There are no filtering parameters and no pagination — the response is always the latest 20 rounds. For a longer historical record, you would need to call the endpoint repeatedly and store results locally.Does the API cover other 1win crash games beyond Lucky Jet VIP?+
get_crash_history and get_game_state. You can fork it on Parse and revise it to add endpoints for other 1win crash game variants.Is individual player bet data or cashout history available?+
bet_count for the active round and round-level coefficients, but does not include per-player bet amounts, cashout multipliers, or usernames. You can fork it on Parse and revise to add an endpoint targeting per-round player activity if that data is accessible.How should I detect when a new round starts using `get_game_state`?+
get_game_state and watch for current_state transitioning to betting. The state_changed_at timestamp marks when the phase change occurred, and current_time gives the server's current time so you can calculate elapsed time in the current phase.