Discover/Skywings API
live

Skywings APIskywings.co.uk

Search flights on Skywings.co.uk by route, date, cabin class, and trip type. Returns pricing, segments, stops, carrier info, and baggage details.

This API takes change requests — .
Endpoint health
verified 56m ago
search_flights
1/1 passing latest checkself-healing
Endpoints
1
Updated
2h ago

What is the Skywings API?

The Skywings.co.uk API exposes 1 endpoint — search_flights — that returns available flight options between any two IATA airport or city codes. Each result includes full pricing, outbound and inbound segment details, carrier information, stop counts, and baggage data. Passenger counts for adults, children, and infants are all configurable, making it straightforward to integrate live flight availability into travel tools.

This call costs2 credits / call— charged only on success
Try it
Number of adult passengers (1-9).
Origin airport or city IATA code (3 letters, e.g. LON for all London airports, LHR for Heathrow, JFK for New York JFK).
Number of infant passengers (0-9).
Number of child passengers (0-9).
Type of trip.
Cabin class for the flight.
Destination airport or city IATA code (3 letters, e.g. DXB for Dubai International, JFK for New York JFK).
When true, only return direct (non-stop) flights.
Return date in ISO format YYYY-MM-DD. Required when trip_type is round_trip.
Departure date in ISO format YYYY-MM-DD.
api.parse.bot/scraper/caf1d00e-e085-4cd9-90c6-c3ce78ee9add/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/caf1d00e-e085-4cd9-90c6-c3ce78ee9add/search_flights?origin=LON&trip_type=round_trip&cabin_class=economy&destination=DXB&return_date=2026-09-25&departure_date=2026-09-18' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

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 skywings-co-uk-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: Skywings flight search — find and inspect flight options."""
from parse_apis.skywings_co_uk_api import Skywings, TripType, CabinClass, InputFormatInvalid

client = Skywings()

# Search round-trip flights London → Dubai, economy class
flights = client.flights.search(
    origin="LON",
    destination="DXB",
    departure_date="2026-09-18",
    return_date="2026-09-25",
    trip_type=TripType.ROUND_TRIP,
    cabin_class=CabinClass.ECONOMY,
    limit=5,
)

for flight in flights:
    print(f"{flight.carrier}  £{flight.total_price:.2f} ({flight.currency})")
    print(f"  Outbound stops: {flight.stops_outbound}")
    # Walk outbound segments
    for seg in flight.outbound_segments:
        print(f"    {seg.origin} → {seg.destination}  {seg.flight_number}  departs {seg.departure_time}")
    # Inbound segments present on round trips
    if flight.inbound_segments:
        for seg in flight.inbound_segments:
            print(f"    {seg.destination} ← {seg.origin}  {seg.flight_number}  baggage: {seg.baggage.checked_bag}")

# Drill-down: cheapest direct flight on a one-way search
direct = client.flights.search(
    origin="LON",
    destination="DXB",
    departure_date="2026-09-18",
    direct_only=True,
    trip_type=TripType.ONE_WAY,
    limit=1,
).first()

if direct is not None:
    seg = direct.outbound_segments[0]
    print(f"Cheapest direct: {seg.carrier} {seg.flight_number}, {seg.duration}")

# Demonstrate error handling for invalid input
try:
    client.flights.search(
        origin="INVALID",
        destination="DXB",
        departure_date="2026-09-18",
        limit=1,
    ).first()
except InputFormatInvalid as e:
    print(f"Bad input: {e.message}")

print("exercised: flights.search (round_trip, one_way, direct_only, error)")
All endpoints · 1 totalmissing one? ·

Search for available flights between two airports. Returns all matching flight options with pricing, segment details (carrier, times, stops, baggage), and search parameters. Each flight result includes outbound and (for round trips) inbound segments with per-leg detail. The upstream API returns all matching results in a single response; there is no pagination. A search with no matching flights returns an empty flights array with total_results=0.

Input
ParamTypeDescription
adultsstringNumber of adult passengers (1-9).
originrequiredstringOrigin airport or city IATA code (3 letters, e.g. LON for all London airports, LHR for Heathrow, JFK for New York JFK).
infantsstringNumber of infant passengers (0-9).
childrenstringNumber of child passengers (0-9).
trip_typestringType of trip.
cabin_classstringCabin class for the flight.
destinationrequiredstringDestination airport or city IATA code (3 letters, e.g. DXB for Dubai International, JFK for New York JFK).
direct_onlybooleanWhen true, only return direct (non-stop) flights.
return_datestringReturn date in ISO format YYYY-MM-DD. Required when trip_type is round_trip.
departure_daterequiredstringDeparture date in ISO format YYYY-MM-DD.
Response
{
  "type": "object",
  "fields": {
    "flights": "array of flight options, each with pricing, segments, and carrier info",
    "search_params": "object echoing the search parameters used",
    "total_results": "integer count of flight options returned"
  },
  "sample": {
    "data": {
      "flights": [
        {
          "carrier": "EK",
          "currency": "GBP",
          "adult_tax": 201.3,
          "total_price": 495.19,
          "stops_inbound": null,
          "stops_outbound": 0,
          "ticket_deadline": null,
          "adult_base_price": 304,
          "inbound_segments": null,
          "outbound_segments": [
            {
              "to": "DXB",
              "from": "STN",
              "cabin": "Economy",
              "stops": "0",
              "baggage": {
                "CarryOn": "1 Pieces",
                "CheckedBag": "30 Kg"
              },
              "carrier": "EK",
              "duration": "07:00",
              "arrival_date": "Wed 16Sep26",
              "arrival_time": "07:05",
              "flight_number": "68",
              "departure_date": "Tue 15Sep26",
              "departure_time": "21:05"
            }
          ]
        }
      ],
      "search_params": {
        "adults": 1,
        "origin": "LON",
        "infants": 0,
        "children": 0,
        "trip_type": "one_way",
        "cabin_class": "economy",
        "destination": "DXB",
        "direct_only": true,
        "return_date": null,
        "departure_date": "2026-09-15"
      },
      "total_results": 12
    },
    "status": "success"
  }
}

About the Skywings API

What the API Returns

The search_flights endpoint accepts an origin and destination as 3-letter IATA codes (e.g. LHR for Heathrow, DXB for Dubai) and returns a flights array, a search_params echo object, and a total_results count. Every item in the flights array contains pricing, carrier identity, segment-level timing, stop information, and baggage allowance details. For round trips, both outbound and inbound segments are returned with per-leg breakdowns.

Key Input Parameters

Beyond the required origin and destination fields, the endpoint accepts trip_type to distinguish one-way from round-trip searches, cabin_class for fare filtering, and direct_only (boolean) to restrict results to non-stop flights. Passenger composition is controlled by separate adults, children, and infants string parameters, each accepting values from 0–9. Omitting optional parameters falls back to defaults inferred from the search context.

Response Structure

The flights array is the core payload. Each flight object carries pricing data alongside segment arrays. Segments include carrier codes, scheduled departure and arrival times, stop counts, and baggage metadata. For round-trip queries the response distinguishes outbound from inbound legs, allowing downstream code to display or price each leg independently. The search_params object mirrors the inputs used, which is useful for caching and cache-key construction.

Reliability & maintenanceVerified

The Skywings API is a managed, monitored endpoint for skywings.co.uk — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when skywings.co.uk 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 skywings.co.uk 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.

Last verified
56m ago
Latest check
1/1 endpoint passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Build a flight price-comparison widget that filters results by cabin class and direct-only preference
  • Track cheapest available fares on a given route over time using the pricing fields in the flights array
  • Display per-leg carrier and timing details in an itinerary builder for round-trip searches
  • Aggregate baggage allowance data across carriers on the same route for a packing-cost calculator
  • Power a travel bot that answers passenger queries about stop counts and flight duration by route
  • Generate fare alerts by polling search_flights for a route and comparing returned pricing across runs
  • Filter available flights by infant or child passenger support for family travel planning tools
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo2005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min
Team$300/mo20,000300 req/min
Company$1,000/mo100,000500 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.

Frequently asked questions
Does Skywings.co.uk have an official developer API?+
Skywings.co.uk does not publish an official developer API or documented public data feed. This Parse API provides structured access to the flight search data available on the site.
How does the search_flights endpoint handle round-trip versus one-way queries?+
Pass the desired trip type via the trip_type parameter. For round-trip searches the response includes both outbound and inbound segment arrays within each flight result, each with its own carrier, timing, stop, and baggage fields. One-way searches return only the outbound segment data.
Does the API return hotel, car rental, or package holiday data from Skywings?+
Not currently. The API covers flight search results only, including pricing, segments, and baggage information. You can fork it on Parse and revise it to add an endpoint targeting other travel product categories the site may list.
Can I retrieve historical fare data or price trends through this API?+
Not currently. The search_flights endpoint returns fares available at the time of the request; it does not expose historical pricing or trend data. You can fork it on Parse and revise it to add a data-logging or trend-aggregation layer on top of repeated calls.
What airport code format does the origin and destination parameter expect?+
Both origin and destination accept standard 3-letter IATA codes. You can use city-level codes that cover multiple airports (e.g. LON for all London airports) or specific airport codes (e.g. LHR for Heathrow). Mixed usage — city code for origin, airport code for destination — is supported.
Page content last updated . Spec covers 1 endpoint from skywings.co.uk.
Related APIs in TravelSee all →
skyscanner.com API
Search for flights and compare prices across multiple booking agents, while exploring airports and cities to plan your trip. View daily and monthly price calendars to find the best deals for your travel dates.
britishairways.com API
Search for British Airways flights between any two airports and filter results by your preferred travel dates and cabin class to find the perfect flight for your trip. Easily compare available options to book your ideal itinerary.
skyairline.com API
Search for flights across SKY Airline routes, explore available airports and travel options, and discover current promotions and brand offerings. Plan your trip efficiently by browsing the airline's complete route network and accessing exclusive deals in one place.
skiplagged.com API
Search for flights across airlines including hidden-city ticketing options, and look up airport information by name or code to find the best travel deals. Access Skiplagged's flight inventory and routing data to discover cheaper itineraries and alternative airport combinations.
skyscanner.co.in API
Search for flights worldwide and compare prices with autocomplete suggestions for airports and destinations. View price calendars to find the cheapest travel dates and explore real-time flight availability and pricing.
flightconnections.com API
Search for flights with detailed information about pricing, schedules, and layover options to find the best travel connections for your trips. Compare multiple flight choices and their costs in one convenient search.
aircanada.com API
Search for Air Canada flights between any two airports and compare pricing across all fare families, from Basic to Business class, along with complete schedule and segment details. Find the perfect flight option with transparent pricing and full flight information to make your booking decision.
smiles.com.br API
Search for available flights on Smiles and compare fares across one-way and round-trip routes. Retrieve pricing for standard Smiles, Clube Smiles, and Smiles+Money fare types, including miles requirements, cash portions, and applicable taxes.