Atlys APIatlys.com ↗
Access Atlys visa data via API: destination countries, pricing breakdowns (total, government fee, service fee), visa types, validity periods, and required documents.
What is the Atlys API?
The Atlys API exposes visa service data across 2 endpoints, covering destination country listings and detailed visa information per country. list_visa_countries returns every destination Atlys supports — including active and coming-soon markets — with a full pricing breakdown, visa type, and validity period. get_country_visa_details drills into a single destination to return required documents, process type, and itemized fees, all filtered by the traveler's residence and citizenship.
curl -X GET 'https://api.parse.bot/scraper/3b96da46-48bb-4613-9b3f-4c7adedcdd11/list_visa_countries?residence=IN&citizenship=IN' \ -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 atlys-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.
"""Atlys Visa Services — browse destinations and drill into visa details."""
from parse_apis.atlys_visa_services_api import Atlys, Residence, CountryNotFound
client = Atlys()
# List available visa destinations for Indian citizens (capped at 5 items).
for summary in client.countries.list(citizenship=Residence.IN, limit=5):
print(summary.name, summary.iso2_code, summary.total_price, summary.currency)
# Drill into the first supported country for full details.
first = client.countries.list(citizenship=Residence.IN, limit=1).first()
if first:
detail = first.details()
print(detail.name, detail.process_type, detail.validity, detail.documents_required)
# Direct lookup by country code.
try:
kenya = client.countries.get(iso2_code="KE")
print(kenya.name, kenya.total_price, kenya.government_fee, kenya.atlys_fee)
except CountryNotFound as exc:
print(f"Country not found: {exc.country_code}")
print("exercised: countries.list / summary.details / countries.get / CountryNotFound")
List all countries Atlys offers visa services for, with pricing breakdown showing total price, government fee, and Atlys service fee. Returns both supported (active) and unsupported (coming soon) destinations. Each country includes visa type, validity period, length of stay, and entry type when available. Paginated as a single page containing all results.
| Param | Type | Description |
|---|---|---|
| residence | string | ISO 3166-1 alpha-2 country code for the traveler's country of residence (e.g. 'IN', 'US'). |
| citizenship | string | ISO 3166-1 alpha-2 country code for the traveler's citizenship (e.g. 'IN', 'US'). |
{
"type": "object",
"fields": {
"countries": "array of country visa objects with pricing breakdown including name, iso2_code, supported, purpose, currency, total_price, government_fee, atlys_fee, visa_type, validity, length_of_stay, is_multiple_entry",
"residence": "string - the residence code used for the query",
"citizenship": "string - the citizenship code used for the query",
"total_countries": "integer - total number of countries returned"
},
"sample": {
"data": {
"countries": [
{
"name": "Thailand",
"purpose": "tourism",
"currency": "INR",
"validity": "90 days",
"atlys_fee": 0,
"iso2_code": "TH",
"supported": true,
"visa_type": "Tourism",
"total_price": 1,
"government_fee": 1,
"length_of_stay": "60 days",
"is_multiple_entry": null
},
{
"name": "Kenya",
"purpose": "tourism",
"currency": "INR",
"validity": "90 days",
"atlys_fee": 0,
"iso2_code": "KE",
"supported": true,
"visa_type": "Tourist",
"total_price": 3450,
"government_fee": 3450,
"length_of_stay": "90 days",
"is_multiple_entry": false
}
],
"residence": "IN",
"citizenship": "IN",
"total_countries": 163
},
"status": "success"
}
}About the Atlys API
What the API Covers
The Atlys API provides structured visa service data for international travel. Both endpoints accept residence and citizenship as ISO 3166-1 alpha-2 country codes, so the data returned reflects what a traveler from a specific country, holding a specific passport, would see when applying for a visa. Pricing figures are denominated in a per-destination currency field and split into total_price, government_fee, and atlys_fee, giving full cost transparency.
list_visa_countries
list_visa_countries returns an array of country visa objects alongside a total_countries count and the residence and citizenship values used for the query. Each entry includes name, iso2_code, supported (a boolean indicating whether the destination is actively bookable or coming soon), purpose, visa_type, validity, and the three pricing fields. This makes it straightforward to build a destination picker or compare costs across markets for a given traveler profile.
get_country_visa_details
get_country_visa_details accepts a required country_code — which must be a code returned by list_visa_countries — along with the optional residence and citizenship filters. It returns all the fields from the list endpoint plus process_type (digital or physical), atlys_fee as a discrete field, and required documents for the application. If the country_code is not recognized in the context of the traveler profile, the endpoint returns a stale_input error rather than an empty result, signaling that the input needs correction.
The Atlys API is a managed, monitored endpoint for atlys.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when atlys.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 atlys.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?+
- Display real-time visa cost breakdowns (government fee vs. service fee) on a travel planning tool for a given passport holder.
- Build a destination explorer filtered by citizenship and residence that shows which countries are actively bookable vs. coming soon.
- Compare visa costs across all supported destinations for a traveler from a specific country of residence.
- Surface required documents for a visa application as part of a pre-trip checklist or travel app onboarding flow.
- Identify visa validity periods and length-of-stay limits when generating multi-destination itinerary options.
- Monitor which new destinations Atlys adds to its active service list by tracking the
supportedflag over time.
| 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 Atlys have an official public developer API?+
What does the `supported` field in list_visa_countries tell me?+
supported: true means Atlys actively processes visa applications for that destination given the queried residence and citizenship. supported: false indicates the destination is listed but not yet bookable — essentially a coming-soon entry. Both states are returned by the endpoint, so you can distinguish live markets from upcoming ones.Do both endpoints require residence and citizenship to return useful data?+
residence and citizenship are optional. When omitted, the endpoints return data without personalizing pricing or eligibility to a specific traveler profile. Providing both parameters — as ISO 3166-1 alpha-2 codes like 'IN' or 'US' — narrows results to what that traveler profile would actually see on Atlys.Does the API return visa application status or track an existing application?+
Does the API return all required documents for every destination?+
get_country_visa_details for a specific destination, but document data may be null or incomplete for destinations where supported is false. Coverage is tied to whether Atlys has fully onboarded that destination. You can fork this API on Parse and revise it to handle or filter out incomplete document entries for coming-soon destinations.