peet APIpeet.ws ↗
Solve Cloudflare Turnstile challenges on the peet.ws demo site and retrieve a fresh verification token via a single API endpoint.
What is the peet API?
The peet.ws Turnstile API exposes 1 endpoint — solve_challenge — that returns a freshly generated Cloudflare Turnstile verification token along with 4 response fields: the token string, a success boolean, the challenge page URL, and the resolved challenge variant. Each call targets the peet.ws managed Turnstile demo and produces a token ready for submission to any form or service gating on Turnstile verification.
curl -X GET 'https://api.parse.bot/scraper/f0279b98-bb71-422c-b654-d8732441e206/solve_challenge?challenge_type=managed' \ -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 peet-ws-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: solve Cloudflare Turnstile challenges via the peet.ws demo API."""
from parse_apis.peet_ws_api import Turnstile, ChallengeType, InvalidInput
client = Turnstile()
# Solve the default managed challenge and inspect the result.
challenge = client.challenges.solve()
print(challenge.challenge_type, challenge.solved, challenge.token[:40])
# Solve a specific variant by passing the enum.
invisible = client.challenges.solve(challenge_type=ChallengeType.INVISIBLE)
print(invisible.page_url, invisible.token[:40])
# Handle an invalid challenge type gracefully.
try:
client.challenges.solve(challenge_type="bad_type") # type: ignore
except InvalidInput as e:
print("Expected error:", e.message)
print("exercised: challenges.solve (managed / invisible / error handling)")
Solves a Cloudflare Turnstile challenge on the peet.ws demo site. Returns the solved token for the specified challenge type. The token is freshly generated on each call.
| Param | Type | Description |
|---|---|---|
| challenge_type | string | The Turnstile challenge variant to solve. |
{
"type": "object",
"fields": {
"token": "string — the solved Turnstile verification token",
"solved": "boolean — always true on success",
"page_url": "string — the URL of the challenge page",
"challenge_type": "string — the challenge variant that was solved"
},
"sample": {
"data": {
"token": "1.Epk3xF9R9upceM67-RJWbXD1V2OaUAFtNXFPmpARBxXQIRwJIShNhR1JyULkYpm2...",
"solved": true,
"page_url": "https://peet.ws/turnstile-test/managed.html",
"challenge_type": "managed"
},
"status": "success"
}
}About the peet API
What the API Returns
The solve_challenge endpoint returns a JSON object with four fields. token is the Cloudflare Turnstile verification string generated for the current session. solved is a boolean that is always true on a successful response — if solving fails, no token is returned. page_url confirms the challenge origin as https://peet.ws/turnstile-test/managed.html. challenge_type echoes back the variant that was solved, which mirrors the value you passed in.
Inputs and Challenge Variants
The single optional input is challenge_type, a string identifying the Turnstile challenge variant to target. Omitting it resolves the default managed challenge presented by the peet.ws demo page. Passing a specific variant string selects a different challenge configuration. Each request produces a distinct token — tokens are not cached or reused across calls.
Scope and Intended Use
This API is scoped to the peet.ws Turnstile demo page only. The returned token is suitable for testing Turnstile integration flows, verifying that your own application correctly accepts and validates Turnstile tokens, or automating form submissions in testing pipelines that require a valid token as a precondition.
The peet API is a managed, monitored endpoint for peet.ws — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when peet.ws 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 peet.ws 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?+
- Automated testing of forms that require a valid Cloudflare Turnstile token before submission
- Verifying that a downstream service correctly accepts and validates Turnstile tokens
- Integration testing for applications that gate access behind Turnstile challenges
- Generating fresh Turnstile tokens in CI/CD pipelines to test authentication flows end-to-end
- Prototyping and demonstrating Turnstile-aware client code without managing challenge resolution manually
- QA workflows that need a real token to exercise Turnstile-protected API endpoints in staging environments
| 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 Cloudflare provide an official developer API for Turnstile?+
What does the solve_challenge endpoint actually return on success?+
token (the Turnstile verification string), solved (boolean, always true on success), page_url (the URL of the challenge page), and challenge_type (the variant that was resolved). There are no additional metadata fields or session identifiers in the response.Are tokens from this API reusable across multiple requests?+
solve_challenge produces a fresh, single-use token. Cloudflare Turnstile tokens are valid for a limited time window and are invalidated after first use. You should call the endpoint immediately before the token is needed rather than storing tokens in advance.Can this API solve Turnstile challenges on sites other than peet.ws?+
page_url will always reflect that origin. You can fork the API on Parse and revise it to target a different Turnstile-protected page URL.Does the API support non-managed Turnstile challenge types, such as invisible or interaction-required variants?+
challenge_type parameter accepts a variant string, but coverage depends on what the peet.ws demo page exposes. Not all Turnstile widget modes may be available through this endpoint. You can fork the API on Parse and revise it to point to a page that hosts the specific variant you need.