# petflight-api (`hyperion88/petflight-api`) Actor

- **URL**: https://apify.com/hyperion88/petflight-api.md
- **Developed by:** [abdul rahman el abyad](https://apify.com/hyperion88) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Here’s a complete README you can paste into `README.md` for **petflight-api**.

````markdown
## PetFlight API

PetFlight is a structured airline pet-travel eligibility API.

It checks whether a pet is likely eligible to travel in the cabin on a specific airline and route using airline policy data, route restrictions, pet details, carrier dimensions, age, and weight.

PetFlight is designed for:

- AI travel agents
- Travel planning applications
- Booking workflows
- Pet travel services
- Airline comparison tools
- MCP clients
- Automated travel assistants
- Agentic applications

The Actor returns structured JSON that software and AI agents can consume directly.

---

### What PetFlight checks

PetFlight currently evaluates:

- Airline
- Airline aliases and IATA codes
- Animal type
- Origin airport
- Origin country
- Destination airport
- Destination country
- Route-specific airline restrictions
- Pet age
- Pet weight
- Carrier weight
- Combined pet + carrier weight
- Carrier length
- Carrier width
- Carrier height
- Cabin pet availability
- Advance reservation requirements
- Cabin restrictions
- Breed-related warnings
- Special route requirements

Each result can also include:

- Official airline source
- Last verification date
- Eligibility violations
- Warnings
- Matching route rules
- Airline limits

---

### Example input

```json
{
  "airline": "Turkish Airlines",
  "animal": "cat",
  "origin": "IST",
  "originCountryCode": "TR",
  "destination": "CDG",
  "destinationCountryCode": "FR",
  "petAgeWeeks": 52,
  "petWeightKg": 5,
  "carrierWeightKg": 1,
  "carrierLengthCm": 40,
  "carrierWidthCm": 30,
  "carrierHeightCm": 23
}
````

***

### Example successful result

```json
{
  "status": "LIKELY_ELIGIBLE",
  "airline": "Turkish Airlines",
  "iataCode": "TK",
  "route": {
    "originAirport": "IST",
    "originCountry": "TR",
    "destinationAirport": "CDG",
    "destinationCountry": "FR",
    "routeRulesEvaluated": true,
    "matchingRouteRules": 0
  },
  "pet": {
    "animal": "cat",
    "ageWeeks": 52,
    "weightKg": 5
  },
  "carrier": {
    "weightKg": 1,
    "lengthCm": 40,
    "widthCm": 30,
    "heightCm": 23
  },
  "totalWeightKg": 6,
  "airlineLimits": {
    "minimumPetAgeWeeks": 10,
    "maximumCombinedWeightKg": 8,
    "carrierMaximumCm": {
      "length": 40,
      "width": 30,
      "height": 23
    }
  },
  "reason": "No cabin eligibility problems were found for the supplied pet, carrier, airline, and route.",
  "violations": [],
  "warnings": [
    "Advance pet reservation is required."
  ],
  "reservationRequired": true,
  "routeRules": [],
  "officialSource": "https://...",
  "lastVerified": "2026-10-01"
}
```

***

### Example rejected result

```json
{
  "status": "NOT_ELIGIBLE",
  "airline": "Lufthansa",
  "iataCode": "LH",
  "totalWeightKg": 9,
  "reason": "Pet plus carrier weighs 9 kg, exceeding the 8 kg cabin limit.",
  "violations": [
    "Pet plus carrier weighs 9 kg, exceeding the 8 kg cabin limit."
  ]
}
```

PetFlight can return multiple violations at the same time.

For example:

```json
{
  "violations": [
    "Pet plus carrier weighs 9 kg, exceeding the 8 kg cabin limit.",
    "Carrier length is 60 cm, exceeding the 55 cm maximum.",
    "Carrier width is 45 cm, exceeding the 40 cm maximum.",
    "Carrier height is 28 cm, exceeding the 23 cm maximum."
  ]
}
```

***

### Route-aware eligibility

A pet can satisfy an airline's normal cabin requirements and still be rejected because of the route.

For example:

```text
Turkish Airlines
IST / TR
→
LHR / GB
```

A pet may pass the airline's normal:

- weight rules
- age rules
- carrier dimensions
- animal type rules

but still receive:

```text
NOT_ELIGIBLE
```

because a route-specific rule prohibits pet transport.

PetFlight stores route restrictions separately from general airline policy so route rules can be evaluated directly rather than buried in free-form text.

***

### Airline aliases

PetFlight supports common airline names, short names, and IATA codes.

For example, these all resolve to the same airline:

```text
Pegasus
Pegasus Airlines
PC
```

Likewise:

```text
Etihad
Etihad Airways
EY
```

and:

```text
Qatar
Qatar Airways
QR
```

This makes PetFlight more tolerant of natural input from humans and AI agents.

***

### Status values

#### `LIKELY_ELIGIBLE`

No known eligibility problem was found using the currently available airline policy and route rules.

This does not guarantee boarding or destination entry.

***

#### `NOT_ELIGIBLE`

One or more known airline or route rules were violated.

The response includes the specific reasons in:

```json
"violations": []
```

***

#### `AIRLINE_NOT_SUPPORTED`

The requested airline could not be matched to a currently supported carrier.

Example:

```json
{
  "status": "AIRLINE_NOT_SUPPORTED",
  "airline": "Banana Airlines",
  "reason": "No supported airline matching \"Banana Airlines\" was found."
}
```

***

### Current airline coverage

PetFlight currently includes structured policy data for:

- Turkish Airlines
- Lufthansa
- KLM
- Air France
- British Airways
- Ryanair
- Wizz Air
- Pegasus Airlines
- AJet
- Emirates
- Qatar Airways
- Etihad Airways
- Iberia
- TAP Air Portugal
- Finnair
- SWISS
- Austrian Airlines
- SAS
- LOT Polish Airlines

Coverage is actively expanding.

***

### Examples of route rules currently supported

PetFlight can represent rules such as:

- pets prohibited to a specific country
- pets prohibited from a specific country
- pets prohibited at a specific airport
- pets requiring cargo transport on a route
- special documentation requirements
- route-specific warnings

Examples include restrictions involving:

- United Kingdom
- United Arab Emirates
- United States
- Bahrain
- Saudi Arabia
- Qatar
- Hong Kong
- Australia
- South Africa

Route coverage varies by airline.

***

### Data model

PetFlight separates airline information into multiple structured layers.

#### Airline policy

General airline rules such as:

```text
pets in cabin
allowed species
maximum combined weight
carrier dimensions
minimum pet age
reservation requirements
breed restrictions
cabin restrictions
official source
verification date
```

#### Route rules

Route-specific conditions such as:

```text
origin country
destination country
origin airport
destination airport
prohibited
requires cargo
warning
special documentation
```

#### Airline aliases

Alternative airline identifiers such as:

```text
Etihad
Etihad Airways
EY
```

All resolve to one airline record.

***

### Input fields

#### `airline`

Airline name, common alias, or supported IATA code.

Example:

```text
Lufthansa
```

or:

```text
LH
```

***

#### `animal`

Currently:

```text
cat
dog
```

***

#### `origin`

Three-letter airport code.

Example:

```text
IST
```

***

#### `originCountryCode`

Two-letter ISO country code.

Example:

```text
TR
```

***

#### `destination`

Three-letter airport code.

Example:

```text
CDG
```

***

#### `destinationCountryCode`

Two-letter ISO country code.

Example:

```text
FR
```

***

#### `petAgeWeeks`

Pet age in weeks.

Example:

```text
52
```

***

#### `petWeightKg`

Pet weight without the carrier.

Example:

```text
5
```

***

#### `carrierWeightKg`

Weight of the empty carrier.

Example:

```text
1
```

***

#### `carrierLengthCm`

Outside carrier length in centimeters.

***

#### `carrierWidthCm`

Outside carrier width in centimeters.

***

#### `carrierHeightCm`

Outside carrier height in centimeters.

***

### Output fields

Typical output includes:

```text
status
airline
iataCode
route
pet
carrier
totalWeightKg
airlineLimits
reason
violations
warnings
reservationRequired
routeRules
officialSource
lastVerified
```

***

### Data quality

PetFlight is designed around structured policy data sourced from official airline documentation.

Where possible, each airline policy includes:

- official source URL
- last verified date

PetFlight prefers:

```text
unknown
warning
not evaluated
```

over inventing or guessing missing rules.

If an airline publishes different limits depending on:

- aircraft
- carrier type
- cabin
- route
- fare
- destination

PetFlight may return a warning instead of forcing those rules into a misleading single value.

***

### Important limitations

PetFlight checks airline pet-travel policies.

It does **not** replace official airline confirmation or government requirements.

A destination country may separately require:

- microchip
- vaccinations
- rabies documentation
- veterinary certificates
- import permits
- quarantine
- parasite treatment
- breed-specific documentation
- customs procedures
- advance government approval

Airlines may also change policies without notice.

PetFlight should therefore be used as:

> a structured eligibility and policy-checking tool

not as:

> a guarantee that a pet will be accepted for boarding or admitted into a destination country.

Always confirm final requirements with the airline and relevant government authorities before travel.

***

### API access

PetFlight can be run programmatically through the Apify API.

The Actor supports access through:

- JavaScript
- Python
- CLI
- HTTP
- OpenAPI
- MCP

This allows PetFlight to be integrated directly into applications, workflows, and AI-agent systems.

***

### MCP / AI agent support

PetFlight is available through Apify's MCP infrastructure.

This allows compatible AI clients and agents to use PetFlight as a tool.

A typical agent workflow can look like:

```text
User:
Can my 5 kg cat fly from Istanbul to Paris on Turkish Airlines?

        ↓

AI agent

        ↓

PetFlight

        ↓

Airline policy lookup
Route rule lookup
Pet eligibility evaluation

        ↓

Structured answer
```

This makes PetFlight suitable as a small specialized tool inside larger travel-planning agents.

***

### Pricing

PetFlight uses pay-per-result pricing.

Current Store pricing:

```text
$30 / 1,000 results
```

Equivalent to:

```text
$0.03 per result
```

The Actor writes one structured eligibility result to the default dataset per successful evaluation.

***

### Example use cases

PetFlight can be used by:

#### AI travel agents

Before suggesting a flight:

```text
Can this passenger's pet travel in cabin on this airline and route?
```

#### Flight comparison applications

Add structured pet-policy information alongside fares and schedules.

#### Pet relocation services

Quickly screen airline options before manual verification.

#### Travel booking workflows

Flag impossible airline/route combinations before checkout.

#### Customer support tools

Automatically answer common pet-travel eligibility questions.

#### Travel assistants

Compare multiple carriers for a specific pet.

***

### Roadmap

Planned expansion includes:

- more airlines
- broader route-rule coverage
- assistance/service animal handling
- aircraft-specific carrier limits
- more detailed breed restrictions
- route-specific minimum-age rules
- cabin-class-specific rules
- aircraft-dependent rules
- checked-hold eligibility
- cargo eligibility
- country import requirements
- vaccination/document requirements
- pet fees
- airline booking lead times
- confidence indicators
- automated policy-change monitoring

***

### Philosophy

Airline pet rules are fragmented across airline websites, PDFs, help centers, route exceptions, and country-specific pages.

PetFlight turns that information into structured data that software can query directly.

Instead of an application or AI agent having to:

```text
search
→ find airline policy
→ read multiple pages
→ interpret exceptions
→ normalize the rules
→ determine eligibility
```

PetFlight aims to provide:

```text
input pet + airline + route
→ structured eligibility result
```

***

### Disclaimer

PetFlight provides informational results based on available airline policy data.

Policies, regulations, aircraft assignments, and destination requirements may change.

A `LIKELY_ELIGIBLE` result does not guarantee acceptance by an airline or admission of an animal into a destination country.

Always verify final arrangements with the airline and relevant government authorities before travel.

````



# Actor input Schema

## `airline` (type: `string`):

Airline to check
## `animal` (type: `string`):

Type of pet
## `origin` (type: `string`):

Three-letter airport code, for example IST
## `originCountryCode` (type: `string`):

Two-letter ISO country code, for example TR
## `destination` (type: `string`):

Three-letter airport code, for example CDG
## `destinationCountryCode` (type: `string`):

Two-letter ISO country code, for example FR
## `petAgeWeeks` (type: `integer`):

Age of the animal in weeks
## `petWeightKg` (type: `number`):

Weight of the animal without its carrier
## `carrierWeightKg` (type: `number`):

Weight of the empty carrier
## `carrierLengthCm` (type: `number`):

Outside length of the carrier
## `carrierWidthCm` (type: `number`):

Outside width of the carrier
## `carrierHeightCm` (type: `number`):

Outside height of the carrier

## Actor input object example

```json
{
  "airline": "Turkish Airlines",
  "animal": "cat",
  "origin": "IST",
  "originCountryCode": "TR",
  "destination": "CDG",
  "destinationCountryCode": "FR",
  "petAgeWeeks": 52,
  "petWeightKg": 5,
  "carrierWeightKg": 1,
  "carrierLengthCm": 40,
  "carrierWidthCm": 30,
  "carrierHeightCm": 23
}
````

# Actor output Schema

## `results` (type: `string`):

Structured pet travel eligibility decision including violations, warnings, route rules, airline limits, and official sources.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperion88/petflight-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("hyperion88/petflight-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call hyperion88/petflight-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hyperion88/petflight-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rbtNtEtDpaYOvYgWJ/builds/SeeeNoTdabgdxaOre/openapi.json